@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/hooks/useSyncOrchestrator.js

@@ -19,36 +19,47 @@
  * Key exports: useSyncOrchestrator, UseSyncOrchestratorInput, WorkspaceSyncStatus
  */
 // === SECTION: Imports & module-level constants ===
-import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import { useState, useEffect, useCallback, useRef, useMemo, useLayoutEffect, } from 'react';
 import { ensureCloudWorkspaceReadyForSyncService, syncUserGlobalSettingsService } from '../sync/syncService';
-import { buildWorkspaceSyncPayloadModel, buildWorkspaceSyncSignatureModel } from '../sync/workspaceSyncModel';
+import { buildWorkspaceSyncV2Candidate, buildWorkspaceSyncV2Signature, createWorkspaceSyncV2FrozenSnapshot, } from '../sync/workspaceSyncV2SnapshotBuilder.js';
+import { normalizeAgentRoleSyncPayload, normalizeTaskforceAgentSkillSyncPayload, } from '../sync/collaborationSyncPayload.js';
+import { hasWorkspaceTaxonomyStatePayload } from '../shared/taxonomyState.js';
 import { useWorkspaceSyncController } from './useWorkspaceSyncController';
 import { normalizeTaskforceTheme } from '../utils/theme';
 import { useRealtimeSync } from './useRealtimeSync';
 import { TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT } from '../utils/contextAssetEvents';
-import { TASKFORCE_AI_PROFILES_MUTATED_EVENT } from '../utils/aiProfileEvents';
+import { dispatchTaskforceAiProfilesMutated, TASKFORCE_AI_PROFILES_MUTATED_EVENT, } from '../utils/aiProfileEvents';
+import { dispatchTaskforceAgentsMutated, TASKFORCE_AGENTS_MUTATED_EVENT, } from '../utils/taskforceAgentEvents';
+import { dispatchTaskforceAgentSkillsMutated, TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, } from '../utils/taskforceAgentSkillEvents';
 import { setLocale as setAppLocale } from '../localization';
 import { normalizeTaskFromApi } from '../utils/taskNormalization.js';
 import { normalizeSyncEventDetails } from '../utils/syncEventDetails';
 import { createSyncAuthCoordinator } from './sync/auth';
 import { createBootstrapTimeoutMonitor, syncBootstrapPhaseTracking } from './sync/bootstrap';
 import { resolvePullSyncReadiness, resolvePushSyncReadiness, resolveRetrySyncReadiness } from './sync/controlPlane';
-import { resolveWorkspaceAutomaticPullPolicy, resolveWorkspaceSyncPresentation, shouldRunWorkspaceStartupRepair, shouldScheduleWorkspaceReactivePush, shouldStartWorkspacePeriodicFullReconcile, shouldStartWorkspacePushWatchdog, } from './sync/lifecyclePolicy';
-import { buildPersistedSyncWatermarksSnapshot, buildTaxonomyStateFingerprint, flattenDocumentReviewComments, flattenTaskEvents, isValidWorkspaceKey, logSyncDebug, normalizeWorkspaceSyncAiProfileSnapshotEntry, parsePersistedSyncWatermarksSnapshot, readPersistedSyncWatermarks, readUserGlobalSyncMeta, savePersistedSyncWatermarks, WORKSPACE_CONCURRENT_WINDOW_MESSAGE, WORKSPACE_FULL_RECONCILE_INTERVAL_MS, writeUserGlobalSyncMeta } from './sync/orchestratorShared';
+import { resolveWorkspaceAutomaticPullPolicy, resolveWorkspaceSyncPresentation, shouldRunWorkspaceStartupRepair, shouldScheduleWorkspaceReactivePush, shouldStartWorkspacePeriodicFullReconcile, shouldStartWorkspacePushWatchdog, WORKSPACE_SYNC_PULL_FRESHNESS_WINDOW_MS, } from './sync/lifecyclePolicy';
+import { buildPersistedSyncWatermarksSnapshot, buildTaxonomyStateFingerprint, flattenDocumentReviewComments, flattenTaskEvents, isValidWorkspaceKey, logSyncDebug, normalizeWorkspaceSyncAiProfileSnapshotEntry, normalizeWorkspaceSyncAgentConversationSnapshotEntry, normalizeWorkspaceSyncTaskforceAgentSnapshotEntry, parsePersistedSyncWatermarksSnapshot, readPersistedSyncWatermarks, readUserGlobalSyncMeta, savePersistedSyncWatermarks, WORKSPACE_CONCURRENT_WINDOW_MESSAGE, WORKSPACE_FULL_RECONCILE_INTERVAL_MS, writeUserGlobalSyncMeta } from './sync/orchestratorShared';
 import { createRealtimeSyncBridge } from './sync/realtime';
 import { createSyncRecoveryCoordinator } from './sync/recovery';
 import { createWorkspaceTransferCoordinator } from './sync/transfers';
-import { aiProfileSyncResourceAdapter, taskSyncResourceAdapter } from '../sync/syncResourceAdapters.js';
+import { aiProfileSyncResourceAdapter, getAiProfileSyncSnapshotFingerprint, getTaskRelationshipSyncChangeKey, getTaxonomySyncChangeKey, taskSyncResourceAdapter, } from '../sync/syncResourceAdapters.js';
+import { useDurableLocalOutboxDrain } from './sync/useDurableLocalOutboxDrain.js';
+import { createBrowserWorkspaceSyncEngineLocalServices } from '../sync/engine/workspaceSyncEngineLocalServices.js';
+import { useLocalSyncCoordinatorSnapshot } from './sync/useLocalSyncCoordinatorSnapshot.js';
+import { isServerOwnedBrowserSyncAuthority, resolveBrowserSyncAuthority, shouldAttachLocalSyncCoordinator, } from './sync/browserSyncAuthority.js';
+import { LocalSyncCoordinatorBrowserClient, LocalSyncCoordinatorBrowserClientError, } from '../sync/coordinator/localSyncCoordinatorBrowserClient.js';
+import { isBrowserSyncRemoteServicesSelectionAuthorized, selectBrowserSyncRemoteServices, } from './sync/browserSyncRemoteServices.js';
 const EMPTY_WORKSPACE_SYNC_REFERENCE_SNAPSHOT_STATUS = {
     documents: false,
     aiProfiles: false,
     assets: false,
     documentReviewSessions: false,
-    annotatedAttachmentSessions: false
+    annotatedAttachmentSessions: false,
+    taskforceAgents: false
 };
 export { normalizeWorkspaceSyncAiProfileSnapshotEntry };
 export function useSyncOrchestrator(input) {
-    const { currentWorkspaceId, cloudAuthConfigured, runtimeMode, authSessionResolved, isAuthenticated, authUserId, projectName, resolveCloudAuthUrl, resolveWebSocketUrl, realtimeSyncEnabled, tasks, archivedTasks, deletedTasks = [], initiatives, workstreams, taxonomies, taxonomyState, setupState, globalTheme, locale, globalWeekStartsOn, themeUseGlobalDefault, setTasks, setArchivedTasks, setAuthBlocked, setIsAuthenticated, checkAuthSession, setGlobalTheme, setCurrentTheme, setSetupState, setLocale, setGlobalWeekStartsOn, fetchPlanningEntities } = input;
+    const { currentWorkspaceId, cloudAuthConfigured, runtimeMode, authSessionResolved, isAuthenticated, authUserId, projectName, resolveCloudAuthUrl, resolveWebSocketUrl, realtimeSyncEnabled, localOutboxDispatchEnabled, localCoordinatorBrowserAuthorityGateEnabled = false, localCoordinatorClient, initiativeFeedActivationEnabled, combinedFeedActivationEnabled, combinedFeedCoverage, tasks, archivedTasks, deletedTasks = [], initiatives, workstreams, taxonomies, taxonomyState, setupState, globalTheme, locale, globalWeekStartsOn, themeUseGlobalDefault, setTasks, setArchivedTasks, setAuthBlocked, setIsAuthenticated, checkAuthSession, setGlobalTheme, setCurrentTheme, setSetupState, setLocale, setGlobalWeekStartsOn, fetchPlanningEntities } = input;
     const taxonomyStateFingerprint = useMemo(() => buildTaxonomyStateFingerprint(taxonomyState), [taxonomyState]);
     // === SECTION: State initialization ===
     const [userGlobalSyncStatus, setUserGlobalSyncStatus] = useState('disconnected');
@@ -62,14 +73,29 @@ export function useSyncOrchestrator(input) {
     const [workspaceSyncSetupIntent, setWorkspaceSyncSetupIntent] = useState(null);
     const [workspaceSyncBusy, setWorkspaceSyncBusy] = useState(false);
     const [workspaceSyncPendingChanges, setWorkspaceSyncPendingChanges] = useState(0);
+    const [workspaceSyncV3OutboxStatus, setWorkspaceSyncV3OutboxStatus] = useState(null);
+    const workspaceSyncV3OutboxStatusRef = useRef(null);
+    const handleWorkspaceSyncV3OutboxStatus = useCallback((status) => {
+        workspaceSyncV3OutboxStatusRef.current = status;
+        setWorkspaceSyncV3OutboxStatus(status);
+    }, []);
     const [workspaceSyncMarkdownDocuments, setWorkspaceSyncMarkdownDocuments] = useState([]);
     const [workspaceSyncMarkdownDocumentsFingerprint, setWorkspaceSyncMarkdownDocumentsFingerprint] = useState('');
     // Ref mirror kept in sync with state — readable synchronously inside callbacks to avoid
     // stale-closure issues when buildWorkspaceSyncPayload is called after an async refresh.
     const workspaceTasksRef = useRef(tasks || []);
     const workspaceArchivedTasksRef = useRef(archivedTasks || []);
+    const workspaceDeletedTasksRef = useRef(deletedTasks || []);
+    const workspaceTaskRelationshipsRef = useRef([]);
+    const [workspaceTaskRelationships, setWorkspaceTaskRelationships] = useState([]);
+    const updateWorkspaceTaskRelationships = useCallback((relationships) => {
+        workspaceTaskRelationshipsRef.current = relationships;
+        setWorkspaceTaskRelationships(relationships);
+    }, []);
     const workspaceInitiativesRef = useRef(initiatives || []);
     const workspaceWorkstreamsRef = useRef(workstreams || []);
+    const workspaceTaxonomyStateRef = useRef(taxonomyState);
+    const workspaceTaxonomiesRef = useRef(taxonomies || []);
     const workspaceSyncMarkdownDocumentsRef = useRef([]);
     const workspaceSyncKnownDocumentPathsRef = useRef(new Set());
     const [workspaceSyncAiProfiles, setWorkspaceSyncAiProfiles] = useState([]);
@@ -90,6 +116,12 @@ export function useSyncOrchestrator(input) {
     const [workspaceSyncAnnotatedAttachmentSessions, setWorkspaceSyncAnnotatedAttachmentSessions] = useState([]);
     const [workspaceSyncAnnotatedAttachmentSessionsFingerprint, setWorkspaceSyncAnnotatedAttachmentSessionsFingerprint] = useState('');
     const workspaceSyncAnnotatedAttachmentSessionsRef = useRef([]);
+    const [workspaceSyncTaskforceAgents, setWorkspaceSyncTaskforceAgents] = useState([]);
+    const [workspaceSyncTaskforceAgentsFingerprint, setWorkspaceSyncTaskforceAgentsFingerprint] = useState('');
+    const workspaceSyncTaskforceAgentsRef = useRef([]);
+    const workspaceSyncAgentRolesRef = useRef([]);
+    const workspaceSyncTaskforceAgentSkillsRef = useRef([]);
+    const workspaceSyncAgentConversationsRef = useRef([]);
     const [workspaceSyncReferenceSnapshotStatus, setWorkspaceSyncReferenceSnapshotStatus] = useState(EMPTY_WORKSPACE_SYNC_REFERENCE_SNAPSHOT_STATUS);
     const [realtimeConnectionState, setRealtimeConnectionState] = useState('degraded-fallback');
     const [realtimeTelemetry, setRealtimeTelemetry] = useState({
@@ -111,12 +143,15 @@ export function useSyncOrchestrator(input) {
     const workspaceSyncAssetsFingerprintRef = useRef('');
     const workspaceSyncDocumentReviewSessionsFingerprintRef = useRef('');
     const workspaceSyncAnnotatedAttachmentSessionsFingerprintRef = useRef('');
+    const workspaceSyncTaskforceAgentsFingerprintRef = useRef('');
     const syncInFlightRef = useRef(false);
     const realtimePullDebounceRef = useRef(null);
     const realtimeSuppressedEventIdsRef = useRef(new Set());
     const realtimeSuppressedEventQueueRef = useRef([]);
     const workspacePendingPushReplayRef = useRef(null);
+    const workspaceBlockedPushSignatureRef = useRef('');
     const retryWorkspaceSyncRef = useRef(() => Promise.resolve(false));
+    const browserExecutionFenceDiagnosticEpochRef = useRef('');
     const syncUserGlobalSettingsRef = useRef(async () => { });
     const bootstrapPhaseStartedAtRef = useRef(null);
     const bootstrapLastProgressAtRef = useRef(null);
@@ -153,14 +188,55 @@ export function useSyncOrchestrator(input) {
             }));
     }, []);
     const workspaceSyncReferenceSnapshotsReady = Object.values(workspaceSyncReferenceSnapshotStatus).every(Boolean);
-    const { workspaceRetryAt, isWorkspaceRetryPending, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, clearWorkspaceRetry, scheduleWorkspaceRetry, persistWorkspaceSyncPatch, applyWorkspaceSyncPatchLocally, readWorkspaceSyncStateSnapshot, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot: applyWorkspaceSyncStateSnapshotBase, saveWorkspaceCloudSyncSettings: saveWorkspaceCloudSyncSettingsBase, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, forceClearWorkspaceSyncLease } = useWorkspaceSyncController({
+    const effectiveLocalCoordinatorClient = useMemo(() => localCoordinatorClient || new LocalSyncCoordinatorBrowserClient(), [localCoordinatorClient]);
+    const localCoordinatorAttachmentEnabled = shouldAttachLocalSyncCoordinator({
+        runtimeMode,
+    });
+    const localCoordinator = useLocalSyncCoordinatorSnapshot({
+        // Durable dispatch must be able to reattach after a local server restart
+        // even when the browser's derived auth state is stale. The coordinator
+        // route remains the authority and validates the session cookie itself.
+        enabled: localCoordinatorAttachmentEnabled,
+        workspaceId: currentWorkspaceId,
+        client: effectiveLocalCoordinatorClient,
+    });
+    const browserSyncAuthority = useMemo(() => resolveBrowserSyncAuthority({
+        enforcementEnabled: localCoordinatorBrowserAuthorityGateEnabled,
+        workspaceId: currentWorkspaceId,
+        phase: localCoordinator.phase,
+        snapshot: localCoordinator.snapshot,
+    }), [
+        currentWorkspaceId,
+        localCoordinator.phase,
+        localCoordinator.snapshot,
+        localCoordinatorBrowserAuthorityGateEnabled,
+    ]);
+    // Durable dispatch, like every browser transfer, uses the permit-backed
+    // coordinator gateway and waits for an exact attached browser owner.
+    const localOutboxCoordinatorAuthority = useMemo(() => resolveBrowserSyncAuthority({
+        enforcementEnabled: true,
+        workspaceId: currentWorkspaceId,
+        phase: localCoordinator.phase,
+        snapshot: localCoordinator.snapshot,
+    }), [
+        currentWorkspaceId,
+        localCoordinator.phase,
+        localCoordinator.snapshot,
+    ]);
+    const browserSyncAuthorityRef = useRef(browserSyncAuthority);
+    useLayoutEffect(() => {
+        browserSyncAuthorityRef.current = browserSyncAuthority;
+    }, [browserSyncAuthority]);
+    const isBrowserWorkspaceSyncAuthorized = useCallback(() => browserSyncAuthorityRef.current.browserSchedulingAllowed, []);
+    const { workspaceRetryAt, isWorkspaceRetryPending, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, clearWorkspaceRetry, scheduleWorkspaceRetry, persistWorkspaceSyncPatch, applyWorkspaceSyncPatchLocally, readWorkspaceSyncStateSnapshot, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot: applyWorkspaceSyncStateSnapshotBase, saveWorkspaceCloudSyncSettings: saveWorkspaceCloudSyncSettingsBase, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, forceClearWorkspaceSyncLease, recordWorkspaceSyncCompletion, wasWorkspaceSyncOperationCompletedRecently } = useWorkspaceSyncController({
         currentWorkspaceId,
         setWorkspaceCloudSyncEnabled,
         setWorkspaceSyncPhase,
         setWorkspaceSyncSetupIntent,
         setWorkspaceLastPullAt,
         setWorkspaceLastPushAt,
-        setWorkspaceLastErrorMessage
+        setWorkspaceLastErrorMessage,
+        isWorkspaceOperationAuthorized: isBrowserWorkspaceSyncAuthorized,
     });
     const applyWorkspaceSyncStateSnapshot = useCallback((nextState) => {
         if (nextState.phase === 'attach-cloud' || nextState.phase === 'provision-local') {
@@ -174,6 +250,8 @@ export function useSyncOrchestrator(input) {
     }, [applyWorkspaceSyncStateSnapshotBase]);
     const workspaceLastPushedWatermarksRef = useRef(new Map());
     const workspaceLastPushedTaskChangeKeysRef = useRef(new Map());
+    const workspaceLastPushedTaskRelationshipChangeKeysRef = useRef(new Map());
+    const workspaceLastPushedTaxonomyChangeKeyRef = useRef('');
     const workspaceLastPushedInitiativeIdsRef = useRef(new Set());
     const workspaceLastPushedInitiativeWatermarksRef = useRef(new Map());
     const workspaceLastPushedWorkstreamIdsRef = useRef(new Set());
@@ -191,6 +269,12 @@ export function useSyncOrchestrator(input) {
     const workspaceLastPushedDocumentReviewCommentWatermarksRef = useRef(new Map());
     const workspaceLastPushedAnnotatedAttachmentSessionIdsRef = useRef(new Set());
     const workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef = useRef(new Map());
+    const workspaceLastPushedTaskforceAgentIdsRef = useRef(new Set());
+    const workspaceLastPushedTaskforceAgentWatermarksRef = useRef(new Map());
+    const workspaceLastPushedTaskforceAgentSkillIdsRef = useRef(new Set());
+    const workspaceLastPushedTaskforceAgentSkillWatermarksRef = useRef(new Map());
+    const workspaceLastPushedAgentConversationIdsRef = useRef(new Set());
+    const workspaceLastPushedAgentConversationWatermarksRef = useRef(new Map());
     const workspaceLastPushedTaskEventWatermarksRef = useRef(new Map());
     const hydrateWorkspacePushBaselines = useCallback((persisted) => {
         if (!persisted)
@@ -198,6 +282,8 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushedTaskIdsRef.current = new Set(persisted.taskIds);
         workspaceLastPushedWatermarksRef.current = persisted.taskWatermarks;
         workspaceLastPushedTaskChangeKeysRef.current = persisted.taskChangeKeys || new Map();
+        workspaceLastPushedTaskRelationshipChangeKeysRef.current = persisted.taskRelationshipChangeKeys || new Map();
+        workspaceLastPushedTaxonomyChangeKeyRef.current = persisted.taxonomyChangeKey || '';
         workspaceLastPushedInitiativeIdsRef.current = new Set(Array.from(persisted.initiativeWatermarks.keys()));
         workspaceLastPushedInitiativeWatermarksRef.current = persisted.initiativeWatermarks;
         workspaceLastPushedWorkstreamIdsRef.current = new Set(Array.from(persisted.workstreamWatermarks.keys()));
@@ -205,6 +291,12 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushedAiProfileIdsRef.current = new Set(Array.from(persisted.aiProfileWatermarks.keys()));
         workspaceLastPushedAiProfileWatermarksRef.current = persisted.aiProfileWatermarks;
         workspaceLastPushedAiProfileChangeKeysRef.current = persisted.aiProfileChangeKeys || new Map();
+        workspaceLastPushedTaskforceAgentIdsRef.current = new Set(Array.from((persisted.taskforceAgentWatermarks || new Map()).keys()));
+        workspaceLastPushedTaskforceAgentWatermarksRef.current = persisted.taskforceAgentWatermarks || new Map();
+        workspaceLastPushedTaskforceAgentSkillIdsRef.current = new Set(Array.from((persisted.taskforceAgentSkillWatermarks || new Map()).keys()));
+        workspaceLastPushedTaskforceAgentSkillWatermarksRef.current = persisted.taskforceAgentSkillWatermarks || new Map();
+        workspaceLastPushedAgentConversationIdsRef.current = new Set(Array.from((persisted.agentConversationWatermarks || new Map()).keys()));
+        workspaceLastPushedAgentConversationWatermarksRef.current = persisted.agentConversationWatermarks || new Map();
         workspaceLastPushedDocumentPathsRef.current = new Set(Array.from(persisted.documentWatermarks.keys()));
         workspaceLastPushedDocumentWatermarksRef.current = persisted.documentWatermarks;
         workspaceLastPushedAssetPathsRef.current = new Set(Array.from(persisted.assetWatermarks.keys()));
@@ -223,10 +315,15 @@ export function useSyncOrchestrator(input) {
         taskIds: workspaceLastPushedTaskIdsRef.current,
         taskWatermarks: workspaceLastPushedWatermarksRef.current,
         taskChangeKeys: workspaceLastPushedTaskChangeKeysRef.current,
+        taskRelationshipChangeKeys: workspaceLastPushedTaskRelationshipChangeKeysRef.current,
+        taxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef.current,
         initiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef.current,
         workstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef.current,
         aiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef.current,
         aiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef.current,
+        taskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef.current,
+        taskforceAgentSkillWatermarks: workspaceLastPushedTaskforceAgentSkillWatermarksRef.current,
+        agentConversationWatermarks: workspaceLastPushedAgentConversationWatermarksRef.current,
         documentWatermarks: workspaceLastPushedDocumentWatermarksRef.current,
         assetWatermarks: workspaceLastPushedAssetWatermarksRef.current,
         documentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef.current,
@@ -234,14 +331,44 @@ export function useSyncOrchestrator(input) {
         annotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef.current,
         taskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef.current,
     }), []);
+    const refreshWorkspaceAiProfilePushBaselineFromPersistence = useCallback(() => {
+        if (workspaceBaselineResetReasonRef.current === 'repair-reset'
+            || workspaceBaselineResetReasonRef.current === 'storage-write-failed')
+            return false;
+        const persisted = readPersistedSyncWatermarks(currentWorkspaceId, taxonomyStateFingerprint);
+        if (!persisted || persisted.aiProfileWatermarks.size === 0)
+            return false;
+        workspaceLastPushedAiProfileIdsRef.current = new Set(persisted.aiProfileWatermarks.keys());
+        workspaceLastPushedAiProfileWatermarksRef.current = new Map(persisted.aiProfileWatermarks);
+        workspaceLastPushedAiProfileChangeKeysRef.current = new Map(persisted.aiProfileChangeKeys || []);
+        return true;
+    }, [currentWorkspaceId, taxonomyStateFingerprint]);
     const workspaceStartupRepairRanRef = useRef(false);
     const workspaceStartupFullReconcileRanRef = useRef(false);
+    const workspaceStartupFullReconcileRequestedRef = useRef(false);
     const workspaceRepairModeRef = useRef(false);
+    const workspacePullAfterPushRequestedRef = useRef(false);
     const workspaceAttachBootstrapBaselineSignatureRef = useRef('');
     const workspaceCaptureAttachBootstrapBaselineRef = useRef(false);
     const workspaceDocumentsRefreshIntervalMs = 30_000;
     const workspacePullIntervalMs = realtimeSyncEnabled ? 30_000 : 15_000;
     const workspacePushWatchdogIntervalMs = Math.max(30_000, workspacePullIntervalMs);
+    const [workspaceSyncHealthDeadlineNowMs, setWorkspaceSyncHealthDeadlineNowMs] = useState(null);
+    useEffect(() => {
+        const nowMs = Date.now();
+        if (runtimeMode !== 'local' || !workspaceCloudSyncEnabled || workspaceSyncPhase !== 'active')
+            return;
+        const lastPullMs = workspaceLastPullAt ? Date.parse(workspaceLastPullAt) : NaN;
+        if (!Number.isFinite(lastPullMs))
+            return;
+        const remainingMs = lastPullMs + WORKSPACE_SYNC_PULL_FRESHNESS_WINDOW_MS - nowMs;
+        if (remainingMs <= 0)
+            return;
+        const timeoutId = window.setTimeout(() => {
+            setWorkspaceSyncHealthDeadlineNowMs(Date.now());
+        }, remainingMs + 50);
+        return () => window.clearTimeout(timeoutId);
+    }, [runtimeMode, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceLastPullAt]);
     const workspaceLastSuccessfulSyncAt = useMemo(() => {
         const pullMs = workspaceLastPullAt ? Date.parse(workspaceLastPullAt) : NaN;
         const pushMs = workspaceLastPushAt ? Date.parse(workspaceLastPushAt) : NaN;
@@ -254,19 +381,19 @@ export function useSyncOrchestrator(input) {
             return workspaceLastPushAt;
         return null;
     }, [workspaceLastPullAt, workspaceLastPushAt]);
-    const workspaceSyncPresentation = useMemo(() => resolveWorkspaceSyncPresentation({
+    const workspaceSyncPresentation = resolveWorkspaceSyncPresentation({
         enabled: workspaceCloudSyncEnabled,
         phase: workspaceSyncPhase,
         busy: workspaceSyncBusy,
         retryAt: workspaceRetryAt,
-        lastErrorMessage: workspaceLastErrorMessage
-    }), [
-        workspaceCloudSyncEnabled,
-        workspaceSyncPhase,
-        workspaceSyncBusy,
-        workspaceRetryAt,
-        workspaceLastErrorMessage
-    ]);
+        lastErrorMessage: workspaceLastErrorMessage,
+        lastErrorAt: workspaceLastErrorAt,
+        lastPullAt: workspaceLastPullAt,
+        lastPushAt: workspaceLastPushAt,
+        nowMs: workspaceSyncHealthDeadlineNowMs ?? Date.now(),
+        pendingChanges: workspaceSyncPendingChanges,
+        durableOutbox: workspaceSyncV3OutboxStatus,
+    });
     const workspaceSyncStatus = workspaceSyncPresentation.status;
     const workspaceSyncSummary = workspaceSyncPresentation.summary;
     const workspaceSyncRecommendedAction = workspaceSyncPresentation.recommendedAction;
@@ -482,6 +609,7 @@ export function useSyncOrchestrator(input) {
         workspaceSyncAssetsFingerprintRef.current = '';
         workspaceSyncDocumentReviewSessionsFingerprintRef.current = '';
         workspaceSyncAnnotatedAttachmentSessionsFingerprintRef.current = '';
+        workspaceSyncTaskforceAgentsFingerprintRef.current = '';
         workspaceAttachBootstrapBaselineSignatureRef.current = '';
         workspaceCaptureAttachBootstrapBaselineRef.current = false;
         setWorkspaceSyncMarkdownDocuments([]);
@@ -498,6 +626,11 @@ export function useSyncOrchestrator(input) {
         workspaceSyncAnnotatedAttachmentSessionsRef.current = [];
         setWorkspaceSyncAnnotatedAttachmentSessions([]);
         setWorkspaceSyncAnnotatedAttachmentSessionsFingerprint('');
+        workspaceSyncTaskforceAgentsRef.current = [];
+        workspaceSyncAgentRolesRef.current = [];
+        workspaceSyncAgentConversationsRef.current = [];
+        setWorkspaceSyncTaskforceAgents([]);
+        setWorkspaceSyncTaskforceAgentsFingerprint('');
         setWorkspaceSyncReferenceSnapshotStatus(EMPTY_WORKSPACE_SYNC_REFERENCE_SNAPSHOT_STATUS);
         setWorkspaceLastErrorMessage(null);
         setWorkspaceLastErrorAt(null);
@@ -509,6 +642,8 @@ export function useSyncOrchestrator(input) {
         // changes that happened while the app was closed.
         workspaceLastPushedWatermarksRef.current = new Map();
         workspaceLastPushedTaskChangeKeysRef.current = new Map();
+        workspaceLastPushedTaskRelationshipChangeKeysRef.current = new Map();
+        workspaceLastPushedTaxonomyChangeKeyRef.current = '';
         workspaceLastPushedInitiativeIdsRef.current = new Set();
         workspaceLastPushedInitiativeWatermarksRef.current = new Map();
         workspaceLastPushedWorkstreamIdsRef.current = new Set();
@@ -526,6 +661,12 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushedDocumentReviewCommentWatermarksRef.current = new Map();
         workspaceLastPushedAnnotatedAttachmentSessionIdsRef.current = new Set();
         workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef.current = new Map();
+        workspaceLastPushedTaskforceAgentIdsRef.current = new Set();
+        workspaceLastPushedTaskforceAgentWatermarksRef.current = new Map();
+        workspaceLastPushedTaskforceAgentSkillIdsRef.current = new Set();
+        workspaceLastPushedTaskforceAgentSkillWatermarksRef.current = new Map();
+        workspaceLastPushedAgentConversationIdsRef.current = new Set();
+        workspaceLastPushedAgentConversationWatermarksRef.current = new Map();
         workspaceLastPushedTaskEventWatermarksRef.current = new Map();
         workspaceStartupFullReconcileRanRef.current = Boolean(readWorkspaceSyncStateSnapshot().startupFullReconcileCompletedAt);
         workspaceFullReconcileInFlightRef.current = false;
@@ -584,6 +725,7 @@ export function useSyncOrchestrator(input) {
             workspacePushInFlightRef,
             bootstrapPhaseStartedAtRef,
             bootstrapLastProgressAtRef,
+            isExecutionAuthorized: isBrowserWorkspaceSyncAuthorized,
             setWorkspaceLastErrorMessage: (value) => setWorkspaceLastErrorMessage(value),
             setWorkspaceLastErrorAt: (value) => setWorkspaceLastErrorAt(value),
             setUserGlobalSyncStatus,
@@ -597,26 +739,9 @@ export function useSyncOrchestrator(input) {
         workspaceSyncPhase,
         persistWorkspaceSyncPatchSafely,
         workspacePullInFlightRef,
-        workspacePushInFlightRef
-    ]);
-    const ensureCloudWorkspaceReadyForSync = useCallback(async () => {
-        return ensureCloudWorkspaceReadyForSyncService({
-            cloudAuthConfigured,
-            runtimeMode,
-            isAuthenticated,
-            resolveCloudAuthUrl,
-            workspaceId: currentWorkspaceId,
-            workspaceName: projectName || currentWorkspaceId,
-            allowProvisionOnMismatch: workspaceSyncPhase !== 'attach-cloud'
-        });
-    }, [
-        cloudAuthConfigured,
-        runtimeMode,
-        isAuthenticated,
-        resolveCloudAuthUrl,
-        currentWorkspaceId,
-        projectName,
-        workspaceSyncPhase
+        workspacePushInFlightRef,
+        browserSyncAuthority.authorityEpoch,
+        isBrowserWorkspaceSyncAuthorized,
     ]);
     useEffect(() => {
         workspaceTasksRef.current = tasks || [];
@@ -625,6 +750,18 @@ export function useSyncOrchestrator(input) {
         workspaceArchivedTasksRef.current = archivedTasks || [];
     }, [archivedTasks]);
     useEffect(() => {
+        let cancelled = false;
+        void fetch('/api/taskforce/task-relationships', { method: 'GET', credentials: 'include' })
+            .then((response) => response.ok ? response.json() : null)
+            .then((payload) => {
+            if (!cancelled && Array.isArray(payload?.relationships))
+                updateWorkspaceTaskRelationships(payload.relationships);
+        })
+            .catch(() => undefined);
+        return () => { cancelled = true; };
+    }, [archivedTasks, currentWorkspaceId, tasks, updateWorkspaceTaskRelationships]);
+    useEffect(() => {
+        workspaceDeletedTasksRef.current = deletedTasks || [];
         workspaceDeletedTaskIdsRef.current = new Set((deletedTasks || [])
             .map((entry) => String(entry?.taskId || '').trim())
             .filter((taskId) => taskId.length > 0));
@@ -641,32 +778,161 @@ export function useSyncOrchestrator(input) {
     useEffect(() => {
         workspaceWorkstreamsRef.current = workstreams || [];
     }, [workstreams]);
+    useEffect(() => {
+        workspaceTaxonomyStateRef.current = taxonomyState;
+        workspaceTaxonomiesRef.current = taxonomies || [];
+    }, [taxonomies, taxonomyState]);
     const workspaceForceFullAiProfilePushRef = useRef(false);
     const workspaceFullReconcileInFlightRef = useRef(false);
-    const buildWorkspaceSyncPayload = useCallback((options) => {
-        const forceAllAiProfiles = options?.forceAllAiProfiles === true;
-        // Read documents and assets from refs rather than state so that the freshest data
-        // fetched by an immediately-preceding async refresh is used, even when React has not
-        // yet committed the corresponding state update (stale-closure guard).
-        return buildWorkspaceSyncPayloadModel({
+    const workspaceSyncEngineRuntime = useMemo(() => ({
+        repairMode: workspaceRepairModeRef,
+        forceFullAiProfilePush: workspaceForceFullAiProfilePushRef,
+        pushInFlight: workspacePushInFlightRef,
+        pullInFlight: workspacePullInFlightRef,
+        pullAfterPushRequested: workspacePullAfterPushRequestedRef,
+        pendingPushReplay: workspacePendingPushReplayRef,
+        blockedPushSignature: workspaceBlockedPushSignatureRef,
+        lastPushedSignature: workspaceLastPushedSignatureRef,
+        pendingSignature: workspacePendingSignatureRef,
+        lastPushedTaskIds: workspaceLastPushedTaskIdsRef,
+        deletedTaskIds: workspaceDeletedTaskIdsRef,
+        deletedTaskWatermarks: workspaceDeletedTaskWatermarksRef,
+        pullCursor: workspacePullCursorRef,
+        lastPushedWatermarks: workspaceLastPushedWatermarksRef,
+        lastPushedTaskChangeKeys: workspaceLastPushedTaskChangeKeysRef,
+        lastPushedTaskRelationshipChangeKeys: workspaceLastPushedTaskRelationshipChangeKeysRef,
+        lastPushedTaxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef,
+        lastPushedInitiativeIds: workspaceLastPushedInitiativeIdsRef,
+        lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef,
+        lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef,
+        lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef,
+        lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef,
+        lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef,
+        lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef,
+        lastPushedDocumentPaths: workspaceLastPushedDocumentPathsRef,
+        lastPushedDocumentWatermarks: workspaceLastPushedDocumentWatermarksRef,
+        lastPushedAssetPaths: workspaceLastPushedAssetPathsRef,
+        lastPushedAssetWatermarks: workspaceLastPushedAssetWatermarksRef,
+        lastPushedDocumentReviewSessionIds: workspaceLastPushedDocumentReviewSessionIdsRef,
+        lastPushedDocumentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef,
+        lastPushedDocumentReviewCommentIds: workspaceLastPushedDocumentReviewCommentIdsRef,
+        lastPushedDocumentReviewCommentWatermarks: workspaceLastPushedDocumentReviewCommentWatermarksRef,
+        lastPushedAnnotatedAttachmentSessionIds: workspaceLastPushedAnnotatedAttachmentSessionIdsRef,
+        lastPushedAnnotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef,
+        lastPushedTaskforceAgentIds: workspaceLastPushedTaskforceAgentIdsRef,
+        lastPushedTaskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef,
+        lastPushedTaskforceAgentSkillIds: workspaceLastPushedTaskforceAgentSkillIdsRef,
+        lastPushedTaskforceAgentSkillWatermarks: workspaceLastPushedTaskforceAgentSkillWatermarksRef,
+        lastPushedAgentConversationIds: workspaceLastPushedAgentConversationIdsRef,
+        lastPushedAgentConversationWatermarks: workspaceLastPushedAgentConversationWatermarksRef,
+        lastPushedTaskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef,
+        baselineResetReason: workspaceBaselineResetReasonRef,
+        captureAttachBootstrapBaseline: workspaceCaptureAttachBootstrapBaselineRef,
+        attachBootstrapBaselineSignature: workspaceAttachBootstrapBaselineSignatureRef,
+        startupRepairRan: workspaceStartupRepairRanRef,
+        startupFullReconcileRan: workspaceStartupFullReconcileRanRef,
+        startupFullReconcileRequested: workspaceStartupFullReconcileRequestedRef,
+        fullReconcileInFlight: workspaceFullReconcileInFlightRef,
+        lastBootstrapPhase: lastBootstrapPhaseRef,
+        bootstrapPhaseStartedAtMs: bootstrapPhaseStartedAtRef,
+        bootstrapLastProgressAtMs: bootstrapLastProgressAtRef,
+        realtimeSuppressedEventQueue: realtimeSuppressedEventQueueRef,
+    }), []);
+    const workspaceSyncEngineLocalServices = useMemo(() => createBrowserWorkspaceSyncEngineLocalServices(), []);
+    const workspaceSyncRemoteServicesSelectionRef = useRef(null);
+    const workspaceSyncRemoteServicesSelection = useMemo(() => selectBrowserSyncRemoteServices({
+        workspaceId: currentWorkspaceId,
+        phase: localCoordinator.phase,
+        snapshot: localCoordinator.snapshot,
+        authority: browserSyncAuthority,
+        client: effectiveLocalCoordinatorClient,
+        isSelectionAuthorized: (selection) => (workspaceSyncRemoteServicesSelectionRef.current === selection
+            && isBrowserWorkspaceSyncAuthorized()),
+    }), [
+        browserSyncAuthority.authorityEpoch,
+        browserSyncAuthority.browserSchedulingAllowed,
+        browserSyncAuthority.reason,
+        currentWorkspaceId,
+        effectiveLocalCoordinatorClient,
+        localCoordinator.phase,
+        localCoordinator.snapshot?.credential.coordinatorGeneration,
+        localCoordinator.snapshot?.credential.status,
+        localCoordinator.snapshot?.credential.workspaceId,
+        localCoordinator.snapshot?.serverInstanceId,
+        localCoordinator.snapshot?.state.activeWorkspaceId,
+        localCoordinator.snapshot?.state.coordinatorGeneration,
+        localCoordinator.snapshot?.state.ownershipMode,
+        localCoordinator.snapshot?.state.transitionState,
+        localCoordinatorBrowserAuthorityGateEnabled,
+    ]);
+    const workspaceSyncEngineRemoteServices = workspaceSyncRemoteServicesSelection.remoteServices;
+    useLayoutEffect(() => {
+        workspaceSyncRemoteServicesSelectionRef.current =
+            workspaceSyncRemoteServicesSelection;
+        return () => {
+            if (workspaceSyncRemoteServicesSelectionRef.current
+                === workspaceSyncRemoteServicesSelection) {
+                workspaceSyncRemoteServicesSelectionRef.current = null;
+            }
+        };
+    }, [workspaceSyncRemoteServicesSelection]);
+    const ensureCloudWorkspaceReadyForSync = useCallback(async () => {
+        const capturedSelection = workspaceSyncRemoteServicesSelection;
+        const currentSelection = workspaceSyncRemoteServicesSelectionRef.current
+            ?? { mode: 'blocked', remoteServices: null };
+        if (!workspaceSyncEngineRemoteServices
+            || !isBrowserSyncRemoteServicesSelectionAuthorized({
+                current: currentSelection,
+                captured: capturedSelection,
+                browserSchedulingAllowed: isBrowserWorkspaceSyncAuthorized(),
+            })) {
+            return {
+                success: false,
+                statusCode: 409,
+                transient: true,
+                error: 'Browser workspace sync authority changed before cloud readiness validation.',
+            };
+        }
+        return ensureCloudWorkspaceReadyForSyncService({
+            cloudAuthConfigured,
+            runtimeMode,
+            isAuthenticated,
+            resolveCloudAuthUrl,
+            workspaceId: currentWorkspaceId,
+            workspaceName: projectName || currentWorkspaceId,
+            allowProvisionOnMismatch: workspaceSyncPhase !== 'attach-cloud',
+            remoteServices: workspaceSyncEngineRemoteServices,
+        });
+    }, [
+        cloudAuthConfigured,
+        currentWorkspaceId,
+        isAuthenticated,
+        isBrowserWorkspaceSyncAuthorized,
+        projectName,
+        resolveCloudAuthUrl,
+        runtimeMode,
+        workspaceSyncEngineRemoteServices,
+        workspaceSyncPhase,
+        workspaceSyncRemoteServicesSelection,
+    ]);
+    const currentWorkspaceIdRef = useRef(currentWorkspaceId);
+    currentWorkspaceIdRef.current = currentWorkspaceId;
+    const createWorkspaceSyncV2Snapshot = useCallback(() => {
+        // Read every collection from refs once so payload and signature construction
+        // share one coherent browser snapshot even after an immediately-preceding refresh.
+        return createWorkspaceSyncV2FrozenSnapshot({
+            workspaceId: currentWorkspaceIdRef.current,
             tasks: workspaceTasksRef.current,
             archivedTasks: workspaceArchivedTasksRef.current,
-            taskEvents: flattenTaskEvents(workspaceTasksRef.current, workspaceArchivedTasksRef.current, workspaceInitiativesRef.current, workspaceWorkstreamsRef.current),
-            lastPushedTaskIds: workspaceLastPushedTaskIdsRef.current,
+            taskRelationships: workspaceTaskRelationshipsRef.current,
+            deletedTasks: workspaceDeletedTasksRef.current,
             pendingDeletedTaskIds: workspaceDeletedTaskIdsRef.current,
             pendingDeletedTaskWatermarks: workspaceDeletedTaskWatermarksRef.current,
             initiatives: workspaceInitiativesRef.current,
             workstreams: workspaceWorkstreamsRef.current,
-            taxonomies: taxonomies || [],
-            taxonomyState,
-            lastPushedInitiativeIds: workspaceLastPushedInitiativeIdsRef.current,
-            lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef.current,
-            lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef.current,
-            lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef.current,
+            taxonomies: workspaceTaxonomiesRef.current,
+            taxonomyState: workspaceTaxonomyStateRef.current,
             aiProfiles: workspaceSyncAiProfilesRef.current,
-            lastPushedAiProfileIds: forceAllAiProfiles ? new Set() : workspaceLastPushedAiProfileIdsRef.current,
-            lastPushedAiProfileWatermarks: forceAllAiProfiles ? new Map() : workspaceLastPushedAiProfileWatermarksRef.current,
-            lastPushedAiProfileChangeKeys: forceAllAiProfiles ? new Map() : workspaceLastPushedAiProfileChangeKeysRef.current,
             documents: workspaceSyncMarkdownDocumentsRef.current,
             assets: workspaceSyncAssetsRef.current,
             currentDocumentPaths: workspaceSyncKnownDocumentPathsRef.current,
@@ -674,22 +940,54 @@ export function useSyncOrchestrator(input) {
             documentReviewSessions: workspaceSyncDocumentReviewSessionsRef.current,
             documentReviewComments: workspaceSyncDocumentReviewCommentsRef.current,
             annotatedAttachmentSessions: workspaceSyncAnnotatedAttachmentSessionsRef.current,
-            lastPushedDocumentPaths: workspaceLastPushedDocumentPathsRef.current,
-            lastPushedDocumentWatermarks: workspaceLastPushedDocumentWatermarksRef.current,
-            lastPushedAssetPaths: workspaceLastPushedAssetPathsRef.current,
-            lastPushedAssetWatermarks: workspaceLastPushedAssetWatermarksRef.current,
-            lastPushedDocumentReviewSessionIds: workspaceLastPushedDocumentReviewSessionIdsRef.current,
-            lastPushedDocumentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef.current,
-            lastPushedDocumentReviewCommentIds: workspaceLastPushedDocumentReviewCommentIdsRef.current,
-            lastPushedDocumentReviewCommentWatermarks: workspaceLastPushedDocumentReviewCommentWatermarksRef.current,
-            lastPushedAnnotatedAttachmentSessionIds: workspaceLastPushedAnnotatedAttachmentSessionIdsRef.current,
-            lastPushedAnnotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef.current,
-            lastPushedTaskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef.current,
-            baselineResetReason: workspaceBaselineResetReasonRef.current,
-            lastPushedWatermarks: workspaceLastPushedWatermarksRef.current,
-            lastPushedTaskChangeKeys: workspaceLastPushedTaskChangeKeysRef.current
+            taskforceAgents: workspaceSyncTaskforceAgentsRef.current,
+            agentRoles: workspaceSyncAgentRolesRef.current,
+            taskforceAgentSkills: workspaceSyncTaskforceAgentSkillsRef.current,
+            agentConversations: workspaceSyncAgentConversationsRef.current,
         });
-    }, [taxonomies, taxonomyState]);
+    }, []);
+    const createWorkspaceSyncV2Candidate = useCallback((options) => {
+        const snapshot = createWorkspaceSyncV2Snapshot();
+        return buildWorkspaceSyncV2Candidate({
+            snapshot,
+            forceAllAiProfiles: options?.forceAllAiProfiles === true,
+            baseline: {
+                lastPushedTaskIds: workspaceLastPushedTaskIdsRef.current,
+                lastPushedWatermarks: workspaceLastPushedWatermarksRef.current,
+                lastPushedTaskChangeKeys: workspaceLastPushedTaskChangeKeysRef.current,
+                lastPushedTaskRelationshipChangeKeys: workspaceLastPushedTaskRelationshipChangeKeysRef.current,
+                lastPushedTaxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef.current,
+                lastPushedInitiativeIds: workspaceLastPushedInitiativeIdsRef.current,
+                lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef.current,
+                lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef.current,
+                lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef.current,
+                lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef.current,
+                lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef.current,
+                lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef.current,
+                lastPushedDocumentPaths: workspaceLastPushedDocumentPathsRef.current,
+                lastPushedDocumentWatermarks: workspaceLastPushedDocumentWatermarksRef.current,
+                lastPushedAssetPaths: workspaceLastPushedAssetPathsRef.current,
+                lastPushedAssetWatermarks: workspaceLastPushedAssetWatermarksRef.current,
+                lastPushedDocumentReviewSessionIds: workspaceLastPushedDocumentReviewSessionIdsRef.current,
+                lastPushedDocumentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef.current,
+                lastPushedDocumentReviewCommentIds: workspaceLastPushedDocumentReviewCommentIdsRef.current,
+                lastPushedDocumentReviewCommentWatermarks: workspaceLastPushedDocumentReviewCommentWatermarksRef.current,
+                lastPushedAnnotatedAttachmentSessionIds: workspaceLastPushedAnnotatedAttachmentSessionIdsRef.current,
+                lastPushedAnnotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef.current,
+                lastPushedTaskforceAgentIds: workspaceLastPushedTaskforceAgentIdsRef.current,
+                lastPushedTaskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef.current,
+                lastPushedTaskforceAgentSkillIds: workspaceLastPushedTaskforceAgentSkillIdsRef.current,
+                lastPushedTaskforceAgentSkillWatermarks: workspaceLastPushedTaskforceAgentSkillWatermarksRef.current,
+                lastPushedAgentConversationIds: workspaceLastPushedAgentConversationIdsRef.current,
+                lastPushedAgentConversationWatermarks: workspaceLastPushedAgentConversationWatermarksRef.current,
+                lastPushedTaskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef.current,
+                baselineResetReason: workspaceBaselineResetReasonRef.current,
+            },
+        });
+    }, [createWorkspaceSyncV2Snapshot]);
+    const buildWorkspaceSyncPayload = useCallback((options) => {
+        return createWorkspaceSyncV2Candidate(options).payload;
+    }, [createWorkspaceSyncV2Candidate]);
     const reportSyncEvent = useCallback((workspaceId, event) => {
         if (runtimeMode !== 'local')
             return;
@@ -723,25 +1021,8 @@ export function useSyncOrchestrator(input) {
         }
     }, [runtimeMode]);
     const buildWorkspaceSyncSignature = useCallback(() => {
-        // Read documents and assets from refs for the same stale-closure reason as
-        // buildWorkspaceSyncPayload — the signature must reflect the freshest known data.
-        return buildWorkspaceSyncSignatureModel({
-            workspaceId: currentWorkspaceId,
-            tasks: workspaceTasksRef.current,
-            archivedTasks: workspaceArchivedTasksRef.current,
-            taskEvents: flattenTaskEvents(workspaceTasksRef.current, workspaceArchivedTasksRef.current, workspaceInitiativesRef.current, workspaceWorkstreamsRef.current),
-            pendingDeletedTaskIds: workspaceDeletedTaskIdsRef.current,
-            initiatives: workspaceInitiativesRef.current,
-            workstreams: workspaceWorkstreamsRef.current,
-            taxonomies: taxonomies || [],
-            aiProfiles: workspaceSyncAiProfilesRef.current,
-            documents: workspaceSyncMarkdownDocumentsRef.current,
-            assets: workspaceSyncAssetsRef.current,
-            documentReviewSessions: workspaceSyncDocumentReviewSessionsRef.current,
-            documentReviewComments: workspaceSyncDocumentReviewCommentsRef.current,
-            annotatedAttachmentSessions: workspaceSyncAnnotatedAttachmentSessionsRef.current
-        });
-    }, [currentWorkspaceId, taxonomies, taxonomyState]);
+        return buildWorkspaceSyncV2Signature(createWorkspaceSyncV2Snapshot());
+    }, [createWorkspaceSyncV2Snapshot]);
     const workspaceCoreSyncFingerprint = useMemo(() => JSON.stringify({
         tasks: (tasks || [])
             .map((task) => ({
@@ -795,6 +1076,29 @@ export function useSyncOrchestrator(input) {
         taxonomies: Array.isArray(taxonomies) ? taxonomies : [],
         taxonomyState: taxonomyState && typeof taxonomyState === 'object' ? taxonomyState : null
     }), [tasks, archivedTasks, deletedTasks, initiatives, workstreams, taxonomies, taxonomyState]);
+    useDurableLocalOutboxDrain({
+        enabled: localOutboxDispatchEnabled === true
+            && runtimeMode === 'local'
+            && localOutboxCoordinatorAuthority.browserSchedulingAllowed
+            && workspaceCloudSyncEnabled,
+        workspaceId: currentWorkspaceId,
+        mutationFingerprint: workspaceCoreSyncFingerprint,
+        authorityScope: workspaceSyncRemoteServicesSelection,
+        remoteServices: workspaceSyncEngineRemoteServices,
+        localServices: workspaceSyncEngineLocalServices,
+        isAuthorityCurrent: (authorityScope) => (workspaceSyncRemoteServicesSelectionRef.current === authorityScope
+            && isBrowserWorkspaceSyncAuthorized()),
+        onHydratedEventIds: (eventIds) => {
+            realtimeBridgeRef.current.recordSuppressedEventIds(eventIds, { ttlMs: 60_000 });
+        },
+        onOutboxStatus: handleWorkspaceSyncV3OutboxStatus,
+    });
+    const isDurableRecoveryBlockingOrdinaryPush = useCallback(() => {
+        if (localOutboxDispatchEnabled !== true)
+            return false;
+        const status = workspaceSyncV3OutboxStatusRef.current;
+        return status === null || (status.recovery !== null && status.recovery.state !== 'completed');
+    }, [localOutboxDispatchEnabled]);
     // Fingerprint of per-task attachment counts — changes when the MCP tool saves a new
     // attachment and the React app polls the updated task. Used to trigger an immediate
     // asset snapshot refresh without requiring a cross-process DOM event.
@@ -828,21 +1132,49 @@ export function useSyncOrchestrator(input) {
         workspaceAttachBootstrapBaselineSignatureRef.current = '';
         return false;
     }, []);
+    const refreshWorkspaceSyncTaxonomySnapshot = useCallback(async () => {
+        if (runtimeMode !== 'local')
+            return false;
+        if (!isValidWorkspaceKey(currentWorkspaceId))
+            return false;
+        if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
+            return false;
+        try {
+            const res = await fetch(`/api/taskforce/taxonomy-state?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, { method: 'GET', credentials: 'include' });
+            if (!res.ok)
+                return false;
+            const data = await res.json();
+            if (!hasWorkspaceTaxonomyStatePayload(data))
+                return false;
+            workspaceTaxonomyStateRef.current = data;
+            workspaceTaxonomiesRef.current = Array.isArray(data.taxonomies) ? data.taxonomies : [];
+            return true;
+        }
+        catch (error) {
+            logSyncDebug('taxonomy_snapshot_refresh_failed', {
+                workspaceId: currentWorkspaceId,
+                error: String(error?.message || error || '')
+            });
+            return false;
+        }
+    }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated]);
     const refreshWorkspaceSyncMarkdownDocumentsSnapshot = useCallback(async () => {
         if (runtimeMode !== 'local')
-            return;
+            return false;
         if (!isValidWorkspaceKey(currentWorkspaceId))
-            return;
+            return false;
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
-            return;
+            return false;
         try {
             const res = await fetch(`/api/taskforce/sync/workspace/documents?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
                 method: 'GET',
                 credentials: 'include'
             });
             if (!res.ok)
-                return;
-            const data = await res.json().catch(() => ({}));
+                return false;
+            const data = await res.json();
+            if (!Array.isArray(data?.documents))
+                return false;
             const docs = Array.isArray(data?.documents)
                 ? data.documents
                     .map((entry) => ({
@@ -870,18 +1202,20 @@ export function useSyncOrchestrator(input) {
                 ? data.fingerprint
                 : JSON.stringify(docs.map((entry) => `${entry.path}:${entry.updatedAt}:${entry.content.length}`).sort());
             if (fingerprint === workspaceSyncMarkdownDocumentsFingerprintRef.current)
-                return;
+                return true;
             workspaceSyncMarkdownDocumentsFingerprintRef.current = fingerprint;
             workspaceSyncMarkdownDocumentsRef.current = docs;
             workspaceSyncKnownDocumentPathsRef.current = knownDocumentPaths;
             setWorkspaceSyncMarkdownDocuments(docs);
             setWorkspaceSyncMarkdownDocumentsFingerprint(fingerprint);
+            return true;
         }
         catch (error) {
             logSyncDebug('documents_snapshot_refresh_failed', {
                 workspaceId: currentWorkspaceId,
                 error: String(error?.message || error || '')
             });
+            return false;
         }
         finally {
             markWorkspaceSyncReferenceSnapshotReady('documents');
@@ -890,15 +1224,15 @@ export function useSyncOrchestrator(input) {
     const refreshWorkspaceSyncAiProfilesSnapshot = useCallback(async () => {
         if (runtimeMode !== 'local') {
             setWorkspaceSyncAiProfilesLastSkipReason('runtime-not-local');
-            return;
+            return false;
         }
         if (!isValidWorkspaceKey(currentWorkspaceId)) {
             setWorkspaceSyncAiProfilesLastSkipReason('workspace-id-invalid');
-            return;
+            return false;
         }
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated)) {
             setWorkspaceSyncAiProfilesLastSkipReason(!authSessionResolved ? 'auth-unresolved' : 'auth-required');
-            return;
+            return false;
         }
         setWorkspaceSyncAiProfilesLastSkipReason(null);
         try {
@@ -909,9 +1243,11 @@ export function useSyncOrchestrator(input) {
             if (!res.ok) {
                 setWorkspaceSyncAiProfilesLastFetchError(`HTTP ${res.status}`);
                 setWorkspaceSyncAiProfilesLastFetchAt(new Date().toISOString());
-                return;
+                return false;
             }
-            const data = await res.json().catch(() => ({}));
+            const data = await res.json();
+            if (!Array.isArray(data?.aiProfiles))
+                return false;
             const rawAiProfiles = Array.isArray(data?.aiProfiles) ? data.aiProfiles : [];
             setWorkspaceSyncAiProfilesRawCount(rawAiProfiles.length);
             const aiProfiles = Array.isArray(data?.aiProfiles)
@@ -923,22 +1259,14 @@ export function useSyncOrchestrator(input) {
             setWorkspaceSyncAiProfilesLastFetchAt(new Date().toISOString());
             const fingerprint = typeof data?.fingerprint === 'string'
                 ? data.fingerprint
-                : JSON.stringify(aiProfiles.map((entry) => [
-                    entry.id,
-                    entry.updatedAt,
-                    entry.name,
-                    entry.username,
-                    entry.archivedAt ?? '',
-                    entry.archivedReason ?? '',
-                    entry.mergedIntoProfileId ?? '',
-                    entry.rosterStateUpdatedAt ?? ''
-                ].join(':')).sort());
+                : getAiProfileSyncSnapshotFingerprint(aiProfiles);
             if (fingerprint === workspaceSyncAiProfilesFingerprintRef.current)
-                return;
+                return true;
             workspaceSyncAiProfilesFingerprintRef.current = fingerprint;
             workspaceSyncAiProfilesRef.current = aiProfiles;
             setWorkspaceSyncAiProfiles(aiProfiles);
             setWorkspaceSyncAiProfilesFingerprint(fingerprint);
+            return true;
         }
         catch (error) {
             setWorkspaceSyncAiProfilesLastFetchError(String(error?.message || error || 'unknown-error'));
@@ -947,6 +1275,7 @@ export function useSyncOrchestrator(input) {
                 workspaceId: currentWorkspaceId,
                 error: String(error?.message || error || '')
             });
+            return false;
         }
         finally {
             markWorkspaceSyncReferenceSnapshotReady('aiProfiles');
@@ -954,19 +1283,21 @@ export function useSyncOrchestrator(input) {
     }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, markWorkspaceSyncReferenceSnapshotReady]);
     const refreshWorkspaceSyncAssetsSnapshot = useCallback(async () => {
         if (runtimeMode !== 'local')
-            return;
+            return false;
         if (!isValidWorkspaceKey(currentWorkspaceId))
-            return;
+            return false;
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
-            return;
+            return false;
         try {
             const res = await fetch(`/api/taskforce/sync/workspace/assets?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
                 method: 'GET',
                 credentials: 'include'
             });
             if (!res.ok)
-                return;
-            const data = await res.json().catch(() => ({}));
+                return false;
+            const data = await res.json();
+            if (!Array.isArray(data?.assets))
+                return false;
             const assets = Array.isArray(data?.assets)
                 ? data.assets
                     .map((entry) => ({
@@ -998,18 +1329,20 @@ export function useSyncOrchestrator(input) {
                 ? data.fingerprint
                 : JSON.stringify(assets.map((entry) => `${entry.path}:${entry.updatedAt}:${entry.contentBase64.length}`).sort());
             if (fingerprint === workspaceSyncAssetsFingerprintRef.current)
-                return;
+                return true;
             workspaceSyncAssetsFingerprintRef.current = fingerprint;
             workspaceSyncAssetsRef.current = assets;
             workspaceSyncKnownAssetPathsRef.current = knownAssetPaths;
             setWorkspaceSyncAssets(assets);
             setWorkspaceSyncAssetsFingerprint(fingerprint);
+            return true;
         }
         catch (error) {
             logSyncDebug('assets_snapshot_refresh_failed', {
                 workspaceId: currentWorkspaceId,
                 error: String(error?.message || error || '')
             });
+            return false;
         }
         finally {
             markWorkspaceSyncReferenceSnapshotReady('assets');
@@ -1017,19 +1350,21 @@ export function useSyncOrchestrator(input) {
     }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, markWorkspaceSyncReferenceSnapshotReady]);
     const refreshWorkspaceSyncPlanningEntitiesSnapshot = useCallback(async () => {
         if (runtimeMode !== 'local')
-            return;
+            return false;
         if (!isValidWorkspaceKey(currentWorkspaceId))
-            return;
+            return false;
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
-            return;
+            return false;
         try {
             const res = await fetch(`/api/taskforce/planning/bootstrap?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
                 method: 'GET',
                 credentials: 'include'
             });
             if (!res.ok)
-                return;
-            const data = await res.json().catch(() => ({}));
+                return false;
+            const data = await res.json();
+            if (!Array.isArray(data?.initiatives) || !Array.isArray(data?.workstreams))
+                return false;
             const nextInitiatives = Array.isArray(data?.initiatives)
                 ? data.initiatives.filter((entry) => (Boolean(entry && typeof entry === 'object' && typeof entry.id === 'string')))
                 : [];
@@ -1038,29 +1373,33 @@ export function useSyncOrchestrator(input) {
                 : [];
             workspaceInitiativesRef.current = nextInitiatives;
             workspaceWorkstreamsRef.current = nextWorkstreams;
+            return true;
         }
         catch (error) {
             logSyncDebug('planning_snapshot_refresh_failed', {
                 workspaceId: currentWorkspaceId,
                 error: String(error?.message || error || '')
             });
+            return false;
         }
     }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated]);
     const refreshWorkspaceSyncDocumentReviewSessionsSnapshot = useCallback(async () => {
         if (runtimeMode !== 'local')
-            return;
+            return false;
         if (!isValidWorkspaceKey(currentWorkspaceId))
-            return;
+            return false;
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
-            return;
+            return false;
         try {
             const res = await fetch(`/api/taskforce/sync/workspace/document-reviews?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
                 method: 'GET',
                 credentials: 'include'
             });
             if (!res.ok)
-                return;
-            const data = await res.json().catch(() => ({}));
+                return false;
+            const data = await res.json();
+            if (!Array.isArray(data?.sessions))
+                return false;
             const sessions = Array.isArray(data?.sessions)
                 ? data.sessions
                     .map((entry) => ({
@@ -1088,6 +1427,8 @@ export function useSyncOrchestrator(input) {
                     anchor: entry?.anchor ?? null,
                     order: Number.isFinite(Number(entry?.order)) ? Math.max(0, Math.floor(Number(entry.order))) : 0,
                     authorActorId: typeof entry?.authorActorId === 'string' && entry.authorActorId.trim().length > 0 ? entry.authorActorId.trim() : null,
+                    updatedByActorId: typeof entry?.updatedByActorId === 'string' && entry.updatedByActorId.trim().length > 0 ? entry.updatedByActorId.trim() : null,
+                    deletedByActorId: typeof entry?.deletedByActorId === 'string' && entry.deletedByActorId.trim().length > 0 ? entry.deletedByActorId.trim() : null,
                     createdAt: String(entry?.createdAt || '').trim(),
                     updatedAt: String(entry?.updatedAt || entry?.createdAt || '').trim(),
                     deletedAt: typeof entry?.deletedAt === 'string' && entry.deletedAt.trim().length > 0 ? entry.deletedAt.trim() : null
@@ -1101,18 +1442,20 @@ export function useSyncOrchestrator(input) {
                     ...comments.map((entry) => `${entry.id}:${entry.sessionId}:${entry.updatedAt}:${entry.deletedAt || ''}`).sort()
                 ]);
             if (fingerprint === workspaceSyncDocumentReviewSessionsFingerprintRef.current)
-                return;
+                return true;
             workspaceSyncDocumentReviewSessionsFingerprintRef.current = fingerprint;
             workspaceSyncDocumentReviewSessionsRef.current = sessions;
             workspaceSyncDocumentReviewCommentsRef.current = comments;
             setWorkspaceSyncDocumentReviewSessions(sessions);
             setWorkspaceSyncDocumentReviewSessionsFingerprint(fingerprint);
+            return true;
         }
         catch (error) {
             logSyncDebug('document_review_sessions_snapshot_refresh_failed', {
                 workspaceId: currentWorkspaceId,
                 error: String(error?.message || error || '')
             });
+            return false;
         }
         finally {
             markWorkspaceSyncReferenceSnapshotReady('documentReviewSessions');
@@ -1120,19 +1463,21 @@ export function useSyncOrchestrator(input) {
     }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, markWorkspaceSyncReferenceSnapshotReady]);
     const refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot = useCallback(async () => {
         if (runtimeMode !== 'local')
-            return;
+            return false;
         if (!isValidWorkspaceKey(currentWorkspaceId))
-            return;
+            return false;
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
-            return;
+            return false;
         try {
             const res = await fetch(`/api/taskforce/sync/workspace/annotated-attachments?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
                 method: 'GET',
                 credentials: 'include'
             });
             if (!res.ok)
-                return;
-            const data = await res.json().catch(() => ({}));
+                return false;
+            const data = await res.json();
+            if (!Array.isArray(data?.sessions))
+                return false;
             const sessions = Array.isArray(data?.sessions)
                 ? data.sessions
                     .map((entry) => ({
@@ -1158,22 +1503,94 @@ export function useSyncOrchestrator(input) {
                 ? data.fingerprint
                 : JSON.stringify(sessions.map((entry) => `${entry.id}:${entry.updatedAt}:${entry.taskId}:${entry.baseImageAssetId}:${entry.annotations.length}:${entry.deletedAt || ''}`).sort());
             if (fingerprint === workspaceSyncAnnotatedAttachmentSessionsFingerprintRef.current)
-                return;
+                return true;
             workspaceSyncAnnotatedAttachmentSessionsFingerprintRef.current = fingerprint;
             workspaceSyncAnnotatedAttachmentSessionsRef.current = sessions;
             setWorkspaceSyncAnnotatedAttachmentSessions(sessions);
             setWorkspaceSyncAnnotatedAttachmentSessionsFingerprint(fingerprint);
+            return true;
         }
         catch (error) {
             logSyncDebug('annotated_attachment_sessions_snapshot_refresh_failed', {
                 workspaceId: currentWorkspaceId,
                 error: String(error?.message || error || '')
             });
+            return false;
         }
         finally {
             markWorkspaceSyncReferenceSnapshotReady('annotatedAttachmentSessions');
         }
     }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, markWorkspaceSyncReferenceSnapshotReady]);
+    const refreshWorkspaceSyncTaskforceAgentsSnapshot = useCallback(async () => {
+        if (runtimeMode !== 'local')
+            return false;
+        if (!isValidWorkspaceKey(currentWorkspaceId))
+            return false;
+        if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
+            return false;
+        try {
+            const res = await fetch(`/api/taskforce/sync/workspace/taskforce-agents?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
+                method: 'GET',
+                credentials: 'include'
+            });
+            if (!res.ok)
+                return false;
+            const data = await res.json();
+            if (!Array.isArray(data?.agents)
+                || !Array.isArray(data?.roles)
+                || !Array.isArray(data?.skills)
+                || !Array.isArray(data?.conversations))
+                return false;
+            const agents = Array.isArray(data?.agents)
+                ? data.agents
+                    .map((entry) => normalizeWorkspaceSyncTaskforceAgentSnapshotEntry(entry))
+                    .filter((entry) => entry.id.length > 0 && entry.workspaceId.length > 0)
+                : [];
+            const conversations = Array.isArray(data?.conversations)
+                ? data.conversations
+                    .map((entry) => normalizeWorkspaceSyncAgentConversationSnapshotEntry(entry))
+                    .filter((entry) => (entry.id.length > 0
+                    && entry.workspaceId.length > 0
+                    && entry.agentId.length > 0))
+                : [];
+            const roles = Array.isArray(data?.roles)
+                ? data.roles
+                    .map((entry) => normalizeAgentRoleSyncPayload(entry, currentWorkspaceId))
+                    .filter((entry) => Boolean(entry))
+                : [];
+            const skills = data.skills
+                .map((entry) => normalizeTaskforceAgentSkillSyncPayload(entry, currentWorkspaceId))
+                .filter((entry) => (Boolean(entry && entry.id.length > 0 && entry.workspaceId.length > 0)));
+            const fingerprint = typeof data?.fingerprint === 'string'
+                ? data.fingerprint
+                : JSON.stringify([
+                    ...agents.map((entry) => `${entry.id}:${entry.updatedAt}:${entry.deletedAt || ''}:${entry.name}:${entry.modelTier}`).sort(),
+                    ...roles.map((entry) => `${entry.id}:${entry.updatedAt}:${entry.deletedAt || ''}:${entry.currentRevision}:${entry.currentContentHash}`).sort(),
+                    ...skills.map((entry) => `${entry.id}:${entry.updatedAt}:${entry.revision}:${entry.contentHash}:${entry.lifecycleStatus}`).sort(),
+                    ...conversations.map((entry) => `${entry.id}:${entry.agentId}:${entry.updatedAt}:${entry.deletedAt || ''}:${entry.messages.length}`).sort()
+                ]);
+            if (fingerprint === workspaceSyncTaskforceAgentsFingerprintRef.current)
+                return true;
+            workspaceSyncTaskforceAgentsFingerprintRef.current = fingerprint;
+            workspaceSyncTaskforceAgentsRef.current = agents;
+            workspaceSyncAgentRolesRef.current = roles;
+            workspaceSyncTaskforceAgentSkillsRef.current = skills;
+            workspaceSyncAgentConversationsRef.current = conversations;
+            setWorkspaceSyncTaskforceAgents(agents);
+            setWorkspaceSyncTaskforceAgentsFingerprint(fingerprint);
+            return true;
+        }
+        catch (error) {
+            logSyncDebug('taskforce_agents_snapshot_refresh_failed', {
+                workspaceId: currentWorkspaceId,
+                error: String(error?.message || error || '')
+            });
+            return false;
+        }
+        finally {
+            markWorkspaceSyncReferenceSnapshotReady('taskforceAgents');
+        }
+    }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, markWorkspaceSyncReferenceSnapshotReady]);
     const seedWorkspaceSnapshotPushBaseline = useCallback(() => {
         workspaceLastPushedTaskIdsRef.current = new Set([...workspaceTasksRef.current, ...workspaceArchivedTasksRef.current]
             .map((entry) => String(entry?.id || '').trim())
@@ -1186,6 +1603,13 @@ export function useSyncOrchestrator(input) {
             ...workspaceArchivedTasksRef.current.map((entry) => [String(entry?.id || '').trim(), taskSyncResourceAdapter.getChangeKey({ ...entry, isArchived: true })])
         ]
             .filter(([id]) => id.length > 0));
+        workspaceLastPushedTaskRelationshipChangeKeysRef.current = new Map(workspaceTaskRelationshipsRef.current
+            .map((entry) => [String(entry?.id || '').trim(), getTaskRelationshipSyncChangeKey(entry)])
+            .filter(([id]) => id.length > 0));
+        workspaceLastPushedTaxonomyChangeKeyRef.current = getTaxonomySyncChangeKey({
+            taxonomyState: workspaceTaxonomyStateRef.current,
+            taxonomies: workspaceTaxonomiesRef.current,
+        });
         workspaceLastPushedInitiativeIdsRef.current = new Set(workspaceInitiativesRef.current
             .map((entry) => String(entry?.id || '').trim())
             .filter((id) => id.length > 0));
@@ -1237,6 +1661,38 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef.current = new Map(workspaceSyncAnnotatedAttachmentSessionsRef.current
             .map((entry) => [String(entry?.id || '').trim(), String(entry?.updatedAt || entry?.createdAt || '').trim()])
             .filter(([id]) => id.length > 0));
+        workspaceLastPushedTaskforceAgentIdsRef.current = new Set([
+            ...workspaceSyncTaskforceAgentsRef.current
+                .map((entry) => String(entry?.id || '').trim()),
+            ...workspaceSyncAgentRolesRef.current
+                .map((entry) => `agent-role:${String(entry?.id || '').trim()}`),
+        ]
+            .filter((id) => id.length > 0));
+        workspaceLastPushedTaskforceAgentWatermarksRef.current = new Map([
+            ...workspaceSyncTaskforceAgentsRef.current
+                .map((entry) => [
+                String(entry?.id || '').trim(),
+                String(entry?.deletedAt || entry?.updatedAt || entry?.createdAt || '').trim(),
+            ]),
+            ...workspaceSyncAgentRolesRef.current
+                .map((entry) => [
+                `agent-role:${String(entry?.id || '').trim()}`,
+                String(entry?.deletedAt || entry?.updatedAt || entry?.createdAt || '').trim(),
+            ]),
+        ]
+            .filter(([id]) => id.length > 0));
+        workspaceLastPushedTaskforceAgentSkillIdsRef.current = new Set(workspaceSyncTaskforceAgentSkillsRef.current
+            .map((entry) => String(entry?.id || '').trim())
+            .filter((id) => id.length > 0));
+        workspaceLastPushedTaskforceAgentSkillWatermarksRef.current = new Map(workspaceSyncTaskforceAgentSkillsRef.current
+            .map((entry) => [String(entry?.id || '').trim(), String(entry?.updatedAt || entry?.createdAt || '').trim()])
+            .filter(([id]) => id.length > 0));
+        workspaceLastPushedAgentConversationIdsRef.current = new Set(workspaceSyncAgentConversationsRef.current
+            .map((entry) => String(entry?.id || '').trim())
+            .filter((id) => id.length > 0));
+        workspaceLastPushedAgentConversationWatermarksRef.current = new Map(workspaceSyncAgentConversationsRef.current
+            .map((entry) => [String(entry?.id || '').trim(), String(entry?.deletedAt || entry?.updatedAt || entry?.createdAt || '').trim()])
+            .filter(([id]) => id.length > 0));
         workspaceLastPushedTaskEventWatermarksRef.current = new Map(flattenTaskEvents(workspaceTasksRef.current, workspaceArchivedTasksRef.current, workspaceInitiativesRef.current, workspaceWorkstreamsRef.current)
             .map((entry) => [String(entry?.id || '').trim(), String(entry?.createdAt || '').trim()])
             .filter(([id]) => id.length > 0));
@@ -1244,7 +1700,7 @@ export function useSyncOrchestrator(input) {
         workspaceBaselineResetReasonRef.current = persisted ? null : 'storage-write-failed';
     }, [persistWorkspaceSyncWatermarksSnapshotBestEffort]);
     const refreshLocalWorkspaceTaskCollections = useCallback(async () => {
-        const [tasksRes, archiveRes] = await Promise.all([
+        const [tasksRes, archiveRes, relationshipsRes] = await Promise.all([
             fetch('/api/taskforce/tasks', {
                 method: 'GET',
                 credentials: 'include'
@@ -1252,31 +1708,41 @@ export function useSyncOrchestrator(input) {
             fetch('/api/taskforce/archive', {
                 method: 'GET',
                 credentials: 'include'
+            }),
+            fetch('/api/taskforce/task-relationships', {
+                method: 'GET',
+                credentials: 'include'
             })
         ]);
-        if (tasksRes.ok) {
-            const tasksPayload = await tasksRes.json().catch(() => ({}));
-            const normalizedTasks = Array.isArray(tasksPayload?.tasks)
-                ? tasksPayload.tasks.map((task) => normalizeTaskFromApi(task))
-                : [];
-            setTasks(normalizedTasks);
+        if (!tasksRes.ok || !archiveRes.ok || !relationshipsRes.ok) {
+            throw new Error('Required task collection refresh failed.');
         }
-        if (archiveRes.ok) {
-            const archivePayload = await archiveRes.json().catch(() => ({}));
-            const normalizedArchive = Array.isArray(archivePayload?.archived)
-                ? archivePayload.archived.map((task) => ({
-                    ...normalizeTaskFromApi(task),
-                    isArchived: true
-                }))
-                : [];
-            setArchivedTasks(normalizedArchive);
+        const [tasksPayload, archivePayload, relationshipPayload] = await Promise.all([
+            tasksRes.json(),
+            archiveRes.json(),
+            relationshipsRes.json()
+        ]);
+        if (!Array.isArray(tasksPayload?.tasks)
+            || !Array.isArray(archivePayload?.archived)
+            || !Array.isArray(relationshipPayload?.relationships)) {
+            throw new Error('Required task collection refresh returned an invalid response.');
         }
+        const normalizedTasks = tasksPayload.tasks.map((task) => normalizeTaskFromApi(task));
+        const normalizedArchive = archivePayload.archived.map((task) => ({
+            ...normalizeTaskFromApi(task),
+            isArchived: true
+        }));
+        workspaceTasksRef.current = normalizedTasks;
+        workspaceArchivedTasksRef.current = normalizedArchive;
+        updateWorkspaceTaskRelationships(relationshipPayload.relationships);
+        setTasks(normalizedTasks);
+        setArchivedTasks(normalizedArchive);
         await fetchPlanningEntities().catch(() => {
             logSyncDebug('refresh_planning_entities_failed', {
                 workspaceId: currentWorkspaceId
             });
         });
-    }, [currentWorkspaceId, fetchPlanningEntities, setArchivedTasks, setTasks]);
+    }, [currentWorkspaceId, fetchPlanningEntities, setArchivedTasks, setTasks, updateWorkspaceTaskRelationships]);
     // === SECTION: Auth failure handling & sync readiness ===
     const { handleSyncAuthFailure, ensureWorkspaceSyncReady } = useMemo(() => createSyncAuthCoordinator({
         currentWorkspaceId,
@@ -1307,91 +1773,107 @@ export function useSyncOrchestrator(input) {
         persistWorkspaceSyncPatchSafely
     ]);
     // === SECTION: Push/Pull sync ===
-    const transferCoordinator = useMemo(() => createWorkspaceTransferCoordinator({
-        cloudAuthConfigured,
-        runtimeMode,
-        workspaceCloudSyncEnabled,
-        currentWorkspaceId,
-        workspaceSyncPhase,
-        isAuthenticated,
-        checkAuthSession,
-        resolveCloudAuthUrl,
-        ensureCloudWorkspaceReadyForSync,
-        ensureWorkspaceSyncReady,
-        handleSyncAuthFailure,
-        clearWorkspaceRetry,
-        clearWorkspaceIssue,
-        isWorkspaceRetryPending,
-        scheduleWorkspaceSyncRetry,
-        persistWorkspaceSyncPatchSafely,
-        persistWorkspaceSyncPatchBestEffort,
-        persistWorkspaceSyncWatermarksSnapshotBestEffort,
-        reportSyncEvent,
-        acquireWorkspaceSyncLease,
-        releaseWorkspaceSyncLease,
-        reportWorkspaceWindowContention,
-        refreshWorkspaceSyncMarkdownDocumentsSnapshot,
-        refreshWorkspaceSyncAiProfilesSnapshot,
-        refreshWorkspaceSyncAssetsSnapshot,
-        refreshWorkspaceSyncPlanningEntitiesSnapshot,
-        refreshWorkspaceSyncDocumentReviewSessionsSnapshot,
-        refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot,
-        refreshLocalWorkspaceTaskCollections,
-        buildWorkspaceSyncPayload,
-        buildWorkspaceSyncSignature,
-        seedWorkspaceSnapshotPushBaseline,
-        shouldSuppressAttachBootstrapPush,
-        recordSuppressedEventIds: (...args) => realtimeBridgeRef.current.recordSuppressedEventIds(...args),
-        workspaceRepairModeRef,
-        workspaceForceFullAiProfilePushRef,
-        workspacePushInFlightRef,
-        workspacePullInFlightRef,
-        workspacePendingPushReplayRef,
-        workspaceLastPushedSignatureRef,
-        workspacePendingSignatureRef,
-        workspaceLastPushedTaskIdsRef,
-        workspaceDeletedTaskIdsRef,
-        workspaceDeletedTaskWatermarksRef,
-        workspacePullCursorRef,
-        workspaceLastPushedWatermarksRef,
-        workspaceLastPushedTaskChangeKeysRef,
-        workspaceLastPushedInitiativeIdsRef,
-        workspaceLastPushedInitiativeWatermarksRef,
-        workspaceLastPushedWorkstreamIdsRef,
-        workspaceLastPushedWorkstreamWatermarksRef,
-        workspaceLastPushedAiProfileIdsRef,
-        workspaceLastPushedAiProfileWatermarksRef,
-        workspaceLastPushedAiProfileChangeKeysRef,
-        workspaceLastPushedDocumentPathsRef,
-        workspaceLastPushedDocumentWatermarksRef,
-        workspaceLastPushedAssetPathsRef,
-        workspaceLastPushedAssetWatermarksRef,
-        workspaceLastPushedDocumentReviewSessionIdsRef,
-        workspaceLastPushedDocumentReviewSessionWatermarksRef,
-        workspaceLastPushedDocumentReviewCommentIdsRef,
-        workspaceLastPushedDocumentReviewCommentWatermarksRef,
-        workspaceLastPushedAnnotatedAttachmentSessionIdsRef,
-        workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef,
-        workspaceLastPushedTaskEventWatermarksRef,
-        workspaceBaselineResetReasonRef,
-        workspaceCaptureAttachBootstrapBaselineRef,
-        workspaceStartupFullReconcileRanRef,
-        workspaceFullReconcileInFlightRef,
-        bootstrapLastProgressAtRef,
-        realtimeSuppressedEventQueueRef,
-        setWorkspaceSyncBusy,
-        setUserGlobalSyncStatus,
-        setUserGlobalSyncError,
-        setWorkspaceLastErrorMessage,
-        setWorkspaceLastErrorAt,
-        setWorkspaceLastPullAt,
-        setWorkspaceLastPushAt,
-        setWorkspaceSyncPendingChanges,
-        setTasks,
-        setArchivedTasks
-    }), [
+    const transferCoordinator = useMemo(() => {
+        const capturedSelection = workspaceSyncRemoteServicesSelection;
+        if (!workspaceSyncEngineRemoteServices)
+            return null;
+        return createWorkspaceTransferCoordinator({
+            cloudAuthConfigured,
+            runtimeMode,
+            initiativeFeedActivationEnabled,
+            combinedFeedActivationEnabled,
+            combinedFeedCoverage,
+            workspaceCloudSyncEnabled,
+            currentWorkspaceId,
+            workspaceSyncPhase,
+            isAuthenticated,
+            checkAuthSession,
+            resolveCloudAuthUrl,
+            ensureCloudWorkspaceReadyForSync,
+            ensureWorkspaceSyncReady,
+            handleSyncAuthFailure,
+            clearWorkspaceRetry,
+            clearWorkspaceIssue,
+            isWorkspaceRetryPending,
+            isDurableRecoveryBlockingOrdinaryPush,
+            isExecutionAuthorized: () => (isBrowserSyncRemoteServicesSelectionAuthorized({
+                current: workspaceSyncRemoteServicesSelectionRef.current
+                    ?? { mode: 'blocked', remoteServices: null },
+                captured: capturedSelection,
+                browserSchedulingAllowed: isBrowserWorkspaceSyncAuthorized(),
+                onDenied: () => {
+                    const authority = browserSyncAuthorityRef.current;
+                    if (!authority.serverCommandMode
+                        || browserExecutionFenceDiagnosticEpochRef.current
+                            === authority.authorityEpoch)
+                        return;
+                    browserExecutionFenceDiagnosticEpochRef.current =
+                        authority.authorityEpoch;
+                    reportSyncEvent(currentWorkspaceId, {
+                        eventType: 'handshake',
+                        status: 'error',
+                        statusCode: 409,
+                        errorMessage: 'Browser cloud execution was blocked by persisted server ownership.',
+                        details: {
+                            errorCode: 'SYNC_BROWSER_EXECUTION_FENCED_BY_SERVER_OWNER',
+                            authorityEpoch: authority.authorityEpoch,
+                            capturedTransportMode: capturedSelection.mode,
+                        },
+                    });
+                },
+            })),
+            scheduleWorkspaceSyncRetry,
+            persistWorkspaceSyncPatchSafely,
+            persistWorkspaceSyncPatchBestEffort,
+            persistWorkspaceSyncWatermarksSnapshotBestEffort,
+            refreshWorkspaceAiProfilePushBaselineFromPersistence,
+            reportSyncEvent,
+            acquireWorkspaceSyncLease,
+            releaseWorkspaceSyncLease,
+            recordWorkspaceSyncCompletion,
+            reportWorkspaceWindowContention,
+            refreshWorkspaceSyncMarkdownDocumentsSnapshot,
+            refreshWorkspaceSyncAiProfilesSnapshot,
+            refreshWorkspaceSyncAssetsSnapshot,
+            refreshWorkspaceSyncTaxonomySnapshot,
+            refreshWorkspaceSyncPlanningEntitiesSnapshot,
+            refreshWorkspaceSyncDocumentReviewSessionsSnapshot,
+            refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot,
+            refreshWorkspaceSyncTaskforceAgentsSnapshot,
+            refreshLocalWorkspaceTaskCollections,
+            buildWorkspaceSyncPayload,
+            buildWorkspaceSyncSignature,
+            seedWorkspaceSnapshotPushBaseline,
+            shouldSuppressAttachBootstrapPush,
+            recordSuppressedEventIds: (...args) => (realtimeBridgeRef.current.recordSuppressedEventIds(...args)),
+            runtime: workspaceSyncEngineRuntime,
+            localServices: workspaceSyncEngineLocalServices,
+            remoteServices: workspaceSyncEngineRemoteServices,
+            setWorkspaceSyncBusy,
+            setUserGlobalSyncStatus,
+            setUserGlobalSyncError,
+            setWorkspaceLastErrorMessage,
+            setWorkspaceLastErrorAt,
+            setWorkspaceLastPullAt,
+            setWorkspaceLastPushAt,
+            setWorkspaceSyncPendingChanges,
+            setTasks,
+            setArchivedTasks,
+            scheduleTask: (callback, delayMs) => {
+                const timeoutId = window.setTimeout(callback, delayMs);
+                return { cancel: () => window.clearTimeout(timeoutId) };
+            },
+            logDebug: logSyncDebug,
+            notifyAiProfilesMutated: dispatchTaskforceAiProfilesMutated,
+            notifyAgentsMutated: dispatchTaskforceAgentsMutated,
+            notifyAgentSkillsMutated: dispatchTaskforceAgentSkillsMutated
+        });
+    }, [
         cloudAuthConfigured,
         runtimeMode,
+        initiativeFeedActivationEnabled,
+        combinedFeedActivationEnabled,
+        combinedFeedCoverage,
         workspaceCloudSyncEnabled,
         currentWorkspaceId,
         workspaceSyncPhase,
@@ -1404,29 +1886,47 @@ export function useSyncOrchestrator(input) {
         handleSyncAuthFailure,
         clearWorkspaceRetry,
         clearWorkspaceIssue,
+        isDurableRecoveryBlockingOrdinaryPush,
         scheduleWorkspaceSyncRetry,
         persistWorkspaceSyncPatchSafely,
         persistWorkspaceSyncPatchBestEffort,
         persistWorkspaceSyncWatermarksSnapshotBestEffort,
+        refreshWorkspaceAiProfilePushBaselineFromPersistence,
         reportSyncEvent,
         acquireWorkspaceSyncLease,
         releaseWorkspaceSyncLease,
+        recordWorkspaceSyncCompletion,
         reportWorkspaceWindowContention,
         refreshWorkspaceSyncMarkdownDocumentsSnapshot,
         refreshWorkspaceSyncAiProfilesSnapshot,
         refreshWorkspaceSyncAssetsSnapshot,
+        refreshWorkspaceSyncTaxonomySnapshot,
         refreshWorkspaceSyncPlanningEntitiesSnapshot,
         refreshWorkspaceSyncDocumentReviewSessionsSnapshot,
         refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot,
+        refreshWorkspaceSyncTaskforceAgentsSnapshot,
         refreshLocalWorkspaceTaskCollections,
         buildWorkspaceSyncPayload,
         buildWorkspaceSyncSignature,
         seedWorkspaceSnapshotPushBaseline,
         shouldSuppressAttachBootstrapPush,
+        workspaceSyncRemoteServicesSelection,
+        workspaceSyncEngineRemoteServices,
         setTasks,
         setArchivedTasks
     ]);
-    const { pushWorkspaceChangesToCloud, pullWorkspaceChangesFromCloud } = transferCoordinator;
+    useEffect(() => {
+        transferCoordinator?.resumeDeferredWork();
+    }, [browserSyncAuthority.authorityEpoch, transferCoordinator]);
+    useEffect(() => () => transferCoordinator?.dispose(), [transferCoordinator]);
+    const pushWorkspaceChangesToCloud = useCallback((signature, options) => (transferCoordinator
+        ? transferCoordinator.pushWorkspaceChangesToCloud(signature, options)
+        : Promise.resolve(false)), [transferCoordinator]);
+    const pullWorkspaceChangesFromCloud = useCallback((options) => (transferCoordinator
+        ? transferCoordinator.pullWorkspaceChangesFromCloud(options)
+        : Promise.resolve(false)), [transferCoordinator]);
+    const pullWorkspaceChangesFromCloudRef = useRef(pullWorkspaceChangesFromCloud);
+    pullWorkspaceChangesFromCloudRef.current = pullWorkspaceChangesFromCloud;
     const realtimeBridgeRef = useRef({
         handleRealtimeSignal: () => { },
         recordSuppressedEventIds: () => { },
@@ -1442,6 +1942,9 @@ export function useSyncOrchestrator(input) {
         realtimeSuppressedEventIdsRef,
         clearWorkspaceRetry,
         isWorkspaceRetryPending,
+        isExecutionAuthorized: isBrowserWorkspaceSyncAuthorized,
+        isServerOwned: () => (isServerOwnedBrowserSyncAuthority(browserSyncAuthorityRef.current)),
+        signalServerWake: (eventIds) => localCoordinator.signalWake('realtime', eventIds),
         pullWorkspaceChangesFromCloud
     }), [
         cloudAuthConfigured,
@@ -1450,12 +1953,16 @@ export function useSyncOrchestrator(input) {
         workspaceSyncPhase,
         clearWorkspaceRetry,
         isWorkspaceRetryPending,
+        isBrowserWorkspaceSyncAuthorized,
+        localCoordinator.signalWake,
         pullWorkspaceChangesFromCloud
     ]);
     realtimeBridgeRef.current = realtimeBridge;
     const realtimeSocketUrl = resolveWebSocketUrl('/taskforce-ws');
     const normalizedRealtimeUserId = String(authUserId || '').trim();
     const realtimeEnabled = Boolean(realtimeSyncEnabled
+        && (isBrowserWorkspaceSyncAuthorized()
+            || browserSyncAuthority.serverCommandMode)
         && cloudAuthConfigured
         && runtimeMode === 'local'
         && workspaceCloudSyncEnabled
@@ -1478,8 +1985,28 @@ export function useSyncOrchestrator(input) {
     useEffect(() => {
         return () => realtimeBridge.clearRealtimePullDebounce();
     }, [realtimeBridge]);
+    useEffect(() => {
+        if (browserSyncAuthority.browserSchedulingAllowed)
+            return;
+        clearWorkspaceRetry();
+        realtimeBridgeRef.current.clearRealtimePullDebounce();
+    }, [
+        browserSyncAuthority.authorityEpoch,
+        browserSyncAuthority.browserSchedulingAllowed,
+        clearWorkspaceRetry,
+    ]);
     // === SECTION: Repair & manual retry ===
     const saveWorkspaceCloudSyncSettings = useCallback(async (settings) => {
+        if (browserSyncAuthority.serverCommandMode) {
+            await localCoordinator.issueCommand(settings.enabled ? 'EnableSync' : 'DisableSync');
+            return { success: true };
+        }
+        if (!isBrowserWorkspaceSyncAuthorized()) {
+            return {
+                success: false,
+                error: 'Workspace sync ownership is changing. Wait for the coordinator to become ready.',
+            };
+        }
         return saveWorkspaceCloudSyncSettingsBase(settings, {
             cloudAuthConfigured,
             isAuthenticated,
@@ -1489,7 +2016,10 @@ export function useSyncOrchestrator(input) {
         saveWorkspaceCloudSyncSettingsBase,
         cloudAuthConfigured,
         isAuthenticated,
-        ensureCloudWorkspaceReadyForSync
+        ensureCloudWorkspaceReadyForSync,
+        browserSyncAuthority.serverCommandMode,
+        isBrowserWorkspaceSyncAuthorized,
+        localCoordinator,
     ]);
     const retryUserGlobalSettingsSync = useCallback(async () => {
         await syncUserGlobalSettings({ preferCloudOnFirstSync: false });
@@ -1499,40 +2029,8 @@ export function useSyncOrchestrator(input) {
         workspaceCloudSyncEnabled,
         workspaceSyncPhase,
         workspaceLastPullAt,
-        lastBootstrapPhaseRef,
-        workspaceRepairModeRef,
-        workspaceForceFullAiProfilePushRef,
-        workspaceStartupRepairRanRef,
-        workspaceStartupFullReconcileRanRef,
-        workspaceFullReconcileInFlightRef,
-        workspacePullCursorRef,
-        workspaceAttachBootstrapBaselineSignatureRef,
-        workspaceCaptureAttachBootstrapBaselineRef,
-        workspacePendingSignatureRef,
-        workspaceLastPushedSignatureRef,
-        workspaceLastPushedWatermarksRef,
-        workspaceLastPushedTaskChangeKeysRef,
-        workspaceLastPushedInitiativeIdsRef,
-        workspaceLastPushedInitiativeWatermarksRef,
-        workspaceLastPushedWorkstreamIdsRef,
-        workspaceLastPushedWorkstreamWatermarksRef,
-        workspaceLastPushedAiProfileIdsRef,
-        workspaceLastPushedAiProfileWatermarksRef,
-        workspaceLastPushedAiProfileChangeKeysRef,
-        workspaceLastPushedDocumentPathsRef,
-        workspaceLastPushedDocumentWatermarksRef,
-        workspaceLastPushedAssetPathsRef,
-        workspaceLastPushedAssetWatermarksRef,
-        workspaceLastPushedDocumentReviewSessionIdsRef,
-        workspaceLastPushedDocumentReviewSessionWatermarksRef,
-        workspaceLastPushedDocumentReviewCommentIdsRef,
-        workspaceLastPushedDocumentReviewCommentWatermarksRef,
-        workspaceLastPushedAnnotatedAttachmentSessionIdsRef,
-        workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef,
-        workspaceLastPushedTaskEventWatermarksRef,
-        workspaceBaselineResetReasonRef,
-        bootstrapPhaseStartedAtRef,
-        bootstrapLastProgressAtRef,
+        runtime: workspaceSyncEngineRuntime,
+        localServices: workspaceSyncEngineLocalServices,
         acquireWorkspaceSyncLease,
         releaseWorkspaceSyncLease,
         forceClearWorkspaceSyncLease,
@@ -1548,13 +2046,17 @@ export function useSyncOrchestrator(input) {
         cloudAuthConfigured,
         runtimeMode,
         isAuthenticated,
-        checkAuthSession
+        checkAuthSession,
+        isExecutionAuthorized: isBrowserWorkspaceSyncAuthorized,
+        coordinatorGeneration: localCoordinator.snapshot?.state?.coordinatorGeneration ?? null,
     }), [
         currentWorkspaceId,
         taxonomyStateFingerprint,
         workspaceCloudSyncEnabled,
         workspaceSyncPhase,
         workspaceLastPullAt,
+        workspaceSyncEngineRuntime,
+        workspaceSyncEngineLocalServices,
         acquireWorkspaceSyncLease,
         releaseWorkspaceSyncLease,
         forceClearWorkspaceSyncLease,
@@ -1570,9 +2072,45 @@ export function useSyncOrchestrator(input) {
         cloudAuthConfigured,
         runtimeMode,
         isAuthenticated,
-        checkAuthSession
+        checkAuthSession,
+        isBrowserWorkspaceSyncAuthorized,
+        localCoordinator.snapshot?.state?.coordinatorGeneration,
+    ]);
+    const retryWorkspaceCloudSync = useCallback(async () => {
+        if (browserSyncAuthority.serverCommandMode) {
+            const coordinatorSnapshot = localCoordinator.snapshot
+                || await localCoordinator.refresh();
+            if (!coordinatorSnapshot || coordinatorSnapshot.credential.status !== 'ready') {
+                return false;
+            }
+            await localCoordinator.issueCommand('Retry');
+            return true;
+        }
+        if (!isBrowserWorkspaceSyncAuthorized())
+            return false;
+        return recoveryCoordinator.retryWorkspaceCloudSync();
+    }, [
+        browserSyncAuthority.serverCommandMode,
+        isBrowserWorkspaceSyncAuthorized,
+        localCoordinator,
+        recoveryCoordinator,
+    ]);
+    const resetWorkspaceSyncCursorAndPull = useCallback(async () => {
+        if (browserSyncAuthority.serverCommandMode) {
+            void localCoordinator.issueCommand('Repair').catch(() => {
+                // Coordinator status owns durable error and retry presentation.
+            });
+            return;
+        }
+        if (!isBrowserWorkspaceSyncAuthorized())
+            return;
+        await recoveryCoordinator.resetWorkspaceSyncCursorAndPull();
+    }, [
+        browserSyncAuthority.serverCommandMode,
+        isBrowserWorkspaceSyncAuthorized,
+        localCoordinator,
+        recoveryCoordinator,
     ]);
-    const { retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull } = recoveryCoordinator;
     // === SECTION: Diagnostics & reactive effects ===
     const getWorkspaceSyncDiagnostics = useCallback(() => {
         const pushReadiness = resolvePushSyncReadiness({
@@ -1618,7 +2156,7 @@ export function useSyncOrchestrator(input) {
             lastPullAt: workspaceLastPullAt,
             lastPushAt: workspaceLastPushAt,
             lastErrorAt: workspaceLastErrorAt,
-            pendingChanges: workspaceSyncPendingChanges,
+            pendingChanges: workspaceSyncPendingChanges + (workspaceSyncV3OutboxStatus?.activeDepth || 0),
             lastErrorMessage: workspaceLastErrorMessage,
             recommendedAction: workspaceSyncRecommendedAction,
             pushBlockedReason: pushReadiness.allowed ? null : pushReadiness.reason,
@@ -1639,9 +2177,16 @@ export function useSyncOrchestrator(input) {
             documentReviewSessionSnapshotFingerprint: workspaceSyncDocumentReviewSessionsFingerprint,
             annotatedAttachmentSessionSnapshotCount: workspaceSyncAnnotatedAttachmentSessions.length,
             annotatedAttachmentSessionSnapshotFingerprint: workspaceSyncAnnotatedAttachmentSessionsFingerprint,
+            taskforceAgentSnapshotCount: workspaceSyncTaskforceAgents.length,
+            taskforceAgentSnapshotFingerprint: workspaceSyncTaskforceAgentsFingerprint,
             lastPushedAiProfileCount: workspaceLastPushedAiProfileIdsRef.current.size,
             lastPushedAiProfileWatermarkCount: workspaceLastPushedAiProfileWatermarksRef.current.size,
-            forceFullAiProfilePushQueued: workspaceForceFullAiProfilePushRef.current === true
+            lastPushedTaskforceAgentCount: workspaceLastPushedTaskforceAgentIdsRef.current.size,
+            lastPushedTaskforceAgentWatermarkCount: workspaceLastPushedTaskforceAgentWatermarksRef.current.size,
+            lastPushedAgentConversationCount: workspaceLastPushedAgentConversationIdsRef.current.size,
+            lastPushedAgentConversationWatermarkCount: workspaceLastPushedAgentConversationWatermarksRef.current.size,
+            forceFullAiProfilePushQueued: workspaceForceFullAiProfilePushRef.current === true,
+            durableOutbox: workspaceSyncV3OutboxStatus
         };
     }, [
         cloudAuthConfigured,
@@ -1657,6 +2202,7 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushAt,
         workspaceLastErrorAt,
         workspaceSyncPendingChanges,
+        workspaceSyncV3OutboxStatus,
         workspaceLastErrorMessage,
         workspaceSyncRecommendedAction,
         workspaceSyncMarkdownDocuments.length,
@@ -1670,6 +2216,8 @@ export function useSyncOrchestrator(input) {
         workspaceSyncDocumentReviewSessionsFingerprint,
         workspaceSyncAnnotatedAttachmentSessions.length,
         workspaceSyncAnnotatedAttachmentSessionsFingerprint,
+        workspaceSyncTaskforceAgents.length,
+        workspaceSyncTaskforceAgentsFingerprint,
         isWorkspaceRetryPending
     ]);
     useEffect(() => {
@@ -1692,6 +2240,7 @@ export function useSyncOrchestrator(input) {
         void refreshWorkspaceSyncAssetsSnapshot();
         void refreshWorkspaceSyncDocumentReviewSessionsSnapshot();
         void refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot();
+        void refreshWorkspaceSyncTaskforceAgentsSnapshot();
         const handleContextAssetsMutated = (event) => {
             const detail = event.detail;
             const eventWorkspaceId = String(detail?.workspaceId || '').trim() || 'default';
@@ -1707,8 +2256,28 @@ export function useSyncOrchestrator(input) {
             void refreshWorkspaceSyncAiProfilesSnapshot();
             void refreshWorkspaceSyncAssetsSnapshot();
         };
+        const handleTaskforceAgentsMutated = (event) => {
+            const detail = event.detail;
+            const eventWorkspaceId = String(detail?.workspaceId || '').trim() || 'default';
+            if (eventWorkspaceId !== currentWorkspaceId)
+                return;
+            if (String(detail?.reason || '').trim() === 'sync-apply')
+                return;
+            void refreshWorkspaceSyncTaskforceAgentsSnapshot();
+        };
+        const handleTaskforceAgentSkillsMutated = (event) => {
+            const detail = event.detail;
+            const eventWorkspaceId = String(detail?.workspaceId || '').trim() || 'default';
+            if (eventWorkspaceId !== currentWorkspaceId)
+                return;
+            if (String(detail?.reason || '').trim() === 'sync-apply')
+                return;
+            void refreshWorkspaceSyncTaskforceAgentsSnapshot();
+        };
         window.addEventListener(TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT, handleContextAssetsMutated);
         window.addEventListener(TASKFORCE_AI_PROFILES_MUTATED_EVENT, handleAiProfilesMutated);
+        window.addEventListener(TASKFORCE_AGENTS_MUTATED_EVENT, handleTaskforceAgentsMutated);
+        window.addEventListener(TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, handleTaskforceAgentSkillsMutated);
         const docsIntervalId = window.setInterval(() => {
             void refreshWorkspaceSyncMarkdownDocumentsSnapshot();
         }, workspaceDocumentsRefreshIntervalMs);
@@ -1724,14 +2293,20 @@ export function useSyncOrchestrator(input) {
         const annotatedAttachmentSessionsIntervalId = window.setInterval(() => {
             void refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot();
         }, workspaceDocumentsRefreshIntervalMs);
+        const taskforceAgentsIntervalId = window.setInterval(() => {
+            void refreshWorkspaceSyncTaskforceAgentsSnapshot();
+        }, workspaceDocumentsRefreshIntervalMs);
         return () => {
             window.removeEventListener(TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT, handleContextAssetsMutated);
             window.removeEventListener(TASKFORCE_AI_PROFILES_MUTATED_EVENT, handleAiProfilesMutated);
+            window.removeEventListener(TASKFORCE_AGENTS_MUTATED_EVENT, handleTaskforceAgentsMutated);
+            window.removeEventListener(TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, handleTaskforceAgentSkillsMutated);
             window.clearInterval(docsIntervalId);
             window.clearInterval(aiProfilesIntervalId);
             window.clearInterval(assetsIntervalId);
             window.clearInterval(documentReviewSessionsIntervalId);
             window.clearInterval(annotatedAttachmentSessionsIntervalId);
+            window.clearInterval(taskforceAgentsIntervalId);
         };
     }, [
         cloudAuthConfigured,
@@ -1746,6 +2321,7 @@ export function useSyncOrchestrator(input) {
         refreshWorkspaceSyncAssetsSnapshot,
         refreshWorkspaceSyncDocumentReviewSessionsSnapshot,
         refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot,
+        refreshWorkspaceSyncTaskforceAgentsSnapshot,
         workspaceDocumentsRefreshIntervalMs
     ]);
     // When task attachments change (e.g., after the MCP save_task_attachment tool writes a
@@ -1762,6 +2338,8 @@ export function useSyncOrchestrator(input) {
         refreshWorkspaceSyncContextAssetSnapshots();
     }, [cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, authSessionResolved, isAuthenticated, taskAttachmentsFingerprint, refreshWorkspaceSyncContextAssetSnapshots]);
     useEffect(() => {
+        if (!isBrowserWorkspaceSyncAuthorized())
+            return;
         if (!shouldScheduleWorkspaceReactivePush({
             cloudAuthConfigured,
             runtimeMode,
@@ -1776,6 +2354,9 @@ export function useSyncOrchestrator(input) {
             return;
         if (!signature || signature === workspaceLastPushedSignatureRef.current)
             return;
+        if (workspaceBlockedPushSignatureRef.current === signature)
+            return;
+        workspaceBlockedPushSignatureRef.current = '';
         const pendingPayload = buildWorkspaceSyncPayload();
         setWorkspaceSyncPendingChanges(pendingPayload.changes.length);
         if (workspacePushInFlightRef.current || workspacePullInFlightRef.current) {
@@ -1783,6 +2364,12 @@ export function useSyncOrchestrator(input) {
             return;
         }
         const timeoutId = window.setTimeout(() => {
+            if (!isBrowserWorkspaceSyncAuthorized())
+                return;
+            if (workspacePushInFlightRef.current || workspacePullInFlightRef.current) {
+                workspacePendingSignatureRef.current = buildWorkspaceSyncSignature();
+                return;
+            }
             void pushWorkspaceChangesToCloud(signature);
         }, 1500);
         return () => window.clearTimeout(timeoutId);
@@ -1802,11 +2389,16 @@ export function useSyncOrchestrator(input) {
         workspaceSyncAssetsFingerprint,
         workspaceSyncDocumentReviewSessionsFingerprint,
         workspaceSyncAnnotatedAttachmentSessionsFingerprint,
+        workspaceSyncTaskforceAgentsFingerprint,
         pushWorkspaceChangesToCloud,
         workspacePushInFlightRef,
-        workspacePullInFlightRef
+        workspacePullInFlightRef,
+        browserSyncAuthority.authorityEpoch,
+        isBrowserWorkspaceSyncAuthorized,
     ]);
     useEffect(() => {
+        if (!isBrowserWorkspaceSyncAuthorized())
+            return;
         if (!shouldStartWorkspacePushWatchdog({
             cloudAuthConfigured,
             runtimeMode,
@@ -1817,13 +2409,18 @@ export function useSyncOrchestrator(input) {
         }))
             return;
         const intervalId = window.setInterval(() => {
+            if (!isBrowserWorkspaceSyncAuthorized())
+                return;
             if (workspacePushInFlightRef.current || workspacePullInFlightRef.current)
                 return;
             if (isWorkspaceRetryPending())
                 return;
-            const signature = workspacePendingSignatureRef.current || buildWorkspaceSyncSignature();
+            const signature = buildWorkspaceSyncSignature();
             if (!signature || signature === workspaceLastPushedSignatureRef.current)
                 return;
+            if (workspaceBlockedPushSignatureRef.current === signature)
+                return;
+            workspaceBlockedPushSignatureRef.current = '';
             const pendingPayload = buildWorkspaceSyncPayload();
             setWorkspaceSyncPendingChanges(pendingPayload.changes.length);
             if (pendingPayload.changes.length === 0)
@@ -1842,7 +2439,9 @@ export function useSyncOrchestrator(input) {
         buildWorkspaceSyncPayload,
         pushWorkspaceChangesToCloud,
         isWorkspaceRetryPending,
-        workspacePushWatchdogIntervalMs
+        workspacePushWatchdogIntervalMs,
+        browserSyncAuthority.authorityEpoch,
+        isBrowserWorkspaceSyncAuthorized,
     ]);
     useEffect(() => {
         if (cloudAuthConfigured && runtimeMode === 'local' && workspaceCloudSyncEnabled)
@@ -1856,6 +2455,8 @@ export function useSyncOrchestrator(input) {
         clearWorkspaceRetry
     ]);
     useEffect(() => {
+        if (!isBrowserWorkspaceSyncAuthorized())
+            return;
         const pullPolicy = resolveWorkspaceAutomaticPullPolicy({
             cloudAuthConfigured,
             runtimeMode,
@@ -1868,10 +2469,14 @@ export function useSyncOrchestrator(input) {
         if (!pullPolicy.shouldStart)
             return;
         if (pullPolicy.shouldKickOffImmediately) {
-            void pullWorkspaceChangesFromCloud();
+            void pullWorkspaceChangesFromCloudRef.current();
         }
         const intervalId = window.setInterval(() => {
-            void pullWorkspaceChangesFromCloud();
+            if (!isBrowserWorkspaceSyncAuthorized())
+                return;
+            if (wasWorkspaceSyncOperationCompletedRecently(currentWorkspaceId, 'pull', workspacePullIntervalMs))
+                return;
+            void pullWorkspaceChangesFromCloudRef.current();
         }, workspacePullIntervalMs);
         return () => {
             window.clearInterval(intervalId);
@@ -1883,11 +2488,16 @@ export function useSyncOrchestrator(input) {
         authSessionResolved,
         workspaceSyncPhase,
         workspaceLastPullAt,
+        currentWorkspaceId,
         isWorkspaceRetryPending,
-        pullWorkspaceChangesFromCloud,
-        workspacePullIntervalMs
+        wasWorkspaceSyncOperationCompletedRecently,
+        workspacePullIntervalMs,
+        browserSyncAuthority.authorityEpoch,
+        isBrowserWorkspaceSyncAuthorized,
     ]);
     useEffect(() => {
+        if (!isBrowserWorkspaceSyncAuthorized())
+            return;
         if (!shouldStartWorkspacePeriodicFullReconcile({
             cloudAuthConfigured,
             runtimeMode,
@@ -1898,10 +2508,12 @@ export function useSyncOrchestrator(input) {
         }))
             return;
         const intervalId = window.setInterval(() => {
+            if (!isBrowserWorkspaceSyncAuthorized())
+                return;
             if (workspaceFullReconcileInFlightRef.current)
                 return;
             workspaceFullReconcileInFlightRef.current = true;
-            void pullWorkspaceChangesFromCloud({ forceCursorNull: true }).finally(() => {
+            void pullWorkspaceChangesFromCloudRef.current({ forceCursorNull: true }).finally(() => {
                 workspaceFullReconcileInFlightRef.current = false;
             });
         }, WORKSPACE_FULL_RECONCILE_INTERVAL_MS);
@@ -1913,7 +2525,8 @@ export function useSyncOrchestrator(input) {
         authSessionResolved,
         isAuthenticated,
         workspaceSyncPhase,
-        pullWorkspaceChangesFromCloud
+        browserSyncAuthority.authorityEpoch,
+        isBrowserWorkspaceSyncAuthorized,
     ]);
     useEffect(() => {
         if (runtimeMode !== 'local' || !isAuthenticated)
@@ -1958,6 +2571,8 @@ export function useSyncOrchestrator(input) {
     // missing or stale-tombstoned metadata — a common result of a crash between file write
     // and DB upsert. The repair only adds missing records; it never deletes files.
     useEffect(() => {
+        if (!isBrowserWorkspaceSyncAuthorized())
+            return;
         if (!shouldRunWorkspaceStartupRepair({
             cloudAuthConfigured,
             runtimeMode,
@@ -2003,9 +2618,65 @@ export function useSyncOrchestrator(input) {
         refreshWorkspaceSyncMarkdownDocumentsSnapshot,
         refreshWorkspaceSyncAiProfilesSnapshot,
         refreshWorkspaceSyncAssetsSnapshot,
-        refreshWorkspaceSyncDocumentReviewSessionsSnapshot
+        refreshWorkspaceSyncDocumentReviewSessionsSnapshot,
+        browserSyncAuthority.authorityEpoch,
+        isBrowserWorkspaceSyncAuthorized,
     ]);
     // === SECTION: Return value ===
+    const localCoordinatorDataVersion = (localCoordinatorAttachmentEnabled
+        && localCoordinator.phase === 'ready'
+        && localCoordinator.snapshot?.state.activeWorkspaceId === currentWorkspaceId)
+        ? {
+            coordinatorGeneration: localCoordinator.snapshot.state.coordinatorGeneration,
+            localDataVersion: localCoordinator.snapshot.state.localDataVersion,
+        }
+        : null;
+    const localCoordinatorStatus = localCoordinatorAttachmentEnabled
+        ? {
+            phase: localCoordinator.phase,
+            snapshot: localCoordinator.snapshot,
+            errorMessage: localCoordinator.error?.message || null,
+        }
+        : null;
+    const switchLocalCoordinatorWorkspace = useCallback(async (targetWorkspaceId) => {
+        if (runtimeMode !== 'local'
+            || !localCoordinatorAttachmentEnabled)
+            return false;
+        if (localCoordinator.phase !== 'ready'
+            || !localCoordinator.snapshot) {
+            throw new LocalSyncCoordinatorBrowserClientError('The local sync coordinator is not ready to switch workspaces.', 'SYNC_COORDINATOR_UNAVAILABLE', 409);
+        }
+        await localCoordinator.switchWorkspace(targetWorkspaceId);
+        return true;
+    }, [
+        localCoordinator,
+        localCoordinatorAttachmentEnabled,
+        runtimeMode,
+    ]);
+    const transferLocalCoordinatorOwnership = useCallback(async (targetMode) => {
+        if (runtimeMode !== 'local'
+            || !localCoordinatorAttachmentEnabled)
+            return false;
+        if (localCoordinator.phase !== 'ready'
+            || !localCoordinator.snapshot) {
+            throw new LocalSyncCoordinatorBrowserClientError('The local sync coordinator is not ready to transfer ownership.', 'SYNC_COORDINATOR_UNAVAILABLE', 409);
+        }
+        await localCoordinator.transferOwnership(targetMode);
+        if (targetMode === 'server') {
+            await localCoordinator.issueCommand(workspaceCloudSyncEnabled ? 'EnableSync' : 'DisableSync');
+            if (workspaceCloudSyncEnabled) {
+                void localCoordinator.issueCommand('Sync').catch(() => {
+                    // Coordinator status owns durable error and retry presentation.
+                });
+            }
+        }
+        return true;
+    }, [
+        localCoordinator,
+        localCoordinatorAttachmentEnabled,
+        runtimeMode,
+        workspaceCloudSyncEnabled,
+    ]);
     return {
         userGlobalSyncStatus,
         setUserGlobalSyncStatus,
@@ -2023,7 +2694,12 @@ export function useSyncOrchestrator(input) {
         workspaceSyncSummary,
         workspaceSyncRecommendedAction,
         workspaceSyncBusy,
-        workspaceSyncPendingChanges,
+        workspaceSyncPendingChanges: workspaceSyncPendingChanges + (workspaceSyncV3OutboxStatus?.activeDepth || 0),
+        workspaceTaskRelationships,
+        localCoordinatorDataVersion,
+        localCoordinatorStatus,
+        switchLocalCoordinatorWorkspace,
+        transferLocalCoordinatorOwnership,
         syncInFlightRef,
         workspaceRetryAt,
         isWorkspaceRetryPending,