@taskforcehq/taskforce 0.3.329 → 0.3.330

package/dist/hooks/sync/orchestratorShared.js

@@ -180,6 +180,7 @@ export function buildPersistedSyncWatermarksSnapshot(data) {
         taskRelationshipChangeKeys: Array.from((data.taskRelationshipChangeKeys || new Map()).entries()),
         initiativeWatermarks: Array.from(data.initiativeWatermarks.entries()),
         workstreamWatermarks: Array.from(data.workstreamWatermarks.entries()),
+        planningIdentityWatermarks: Array.from((data.planningIdentityWatermarks || new Map()).entries()),
         aiProfileWatermarks: Array.from(data.aiProfileWatermarks.entries()),
         aiProfileChangeKeys: Array.from((data.aiProfileChangeKeys || new Map()).entries()),
         taskforceAgentWatermarks: Array.from((data.taskforceAgentWatermarks || new Map()).entries()),
@@ -214,6 +215,7 @@ export function parsePersistedSyncWatermarksSnapshot(snapshot, taxonomyStateFing
         taskRelationshipChangeKeys: new Map(Array.isArray(snapshot.taskRelationshipChangeKeys) ? snapshot.taskRelationshipChangeKeys : []),
         initiativeWatermarks: new Map(Array.isArray(snapshot.initiativeWatermarks) ? snapshot.initiativeWatermarks : []),
         workstreamWatermarks: new Map(Array.isArray(snapshot.workstreamWatermarks) ? snapshot.workstreamWatermarks : []),
+        planningIdentityWatermarks: new Map(Array.isArray(snapshot.planningIdentityWatermarks) ? snapshot.planningIdentityWatermarks : []),
         aiProfileWatermarks: new Map(Array.isArray(snapshot.aiProfileWatermarks) ? snapshot.aiProfileWatermarks : []),
         aiProfileChangeKeys: new Map(Array.isArray(snapshot.aiProfileChangeKeys) ? snapshot.aiProfileChangeKeys : []),
         taskforceAgentWatermarks: new Map(Array.isArray(snapshot.taskforceAgentWatermarks) ? snapshot.taskforceAgentWatermarks : []),

package/dist/hooks/sync/useLocalSyncCoordinatorSnapshot.d.ts

@@ -12,9 +12,12 @@ export declare function useLocalSyncCoordinatorSnapshot(input: {
     pollIntervalMs?: number;
     client?: LocalSyncCoordinatorBrowserClient;
 }): {
+    activeCommandType: LocalSyncCoordinatorCommandType | null;
+    activePriorityCommandType: LocalSyncCoordinatorCommandType | null;
     refresh: () => Promise<LocalSyncCoordinatorStatusResponse | null>;
     issueCommand: (type: Exclude<LocalSyncCoordinatorCommandType, "SwitchWorkspace" | "TransferOwnership">, args?: unknown) => Promise<LocalSyncCoordinatorCommandRecord>;
     signalWake: (source: "realtime" | "connectivity", eventIds?: string[]) => Promise<boolean>;
+    clearCredential: () => Promise<boolean>;
     switchWorkspace: (targetWorkspaceId: string) => Promise<LocalSyncCoordinatorStatusResponse["state"]>;
     transferOwnership: (targetMode: "server" | "browser-gateway") => Promise<LocalSyncCoordinatorStatusResponse["state"]>;
     phase: LocalSyncCoordinatorSnapshotPhase;

package/dist/hooks/sync/useLocalSyncCoordinatorSnapshot.js

@@ -15,8 +15,14 @@ export function useLocalSyncCoordinatorSnapshot(input) {
     const requestEpochRef = useRef(0);
     const commandLifecycleRef = useRef(null);
     const priorityCommandLifecycleRef = useRef(null);
+    const [activeCommandType, setActiveCommandType] = useState(null);
+    const [activePriorityCommandType, setActivePriorityCommandType] = useState(null);
     const snapshotRef = useRef(null);
     snapshotRef.current = state.snapshot;
+    useEffect(() => {
+        setActiveCommandType(null);
+        setActivePriorityCommandType(null);
+    }, [input.workspaceId]);
     const resumePendingCommand = useCallback((scope) => {
         const existing = commandLifecycleRef.current;
         if (existing?.workspaceId === input.workspaceId)
@@ -36,14 +42,17 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         const lifecycle = {
             workspaceId: input.workspaceId,
             scope,
+            type: pending.type,
             promise,
         };
         commandLifecycleRef.current = lifecycle;
+        setActiveCommandType(pending.type);
         void promise
             .catch(() => { })
             .finally(() => {
             if (commandLifecycleRef.current === lifecycle) {
                 commandLifecycleRef.current = null;
+                setActiveCommandType(null);
             }
         });
         return promise;
@@ -68,14 +77,17 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         const lifecycle = {
             workspaceId: input.workspaceId,
             scope,
+            type: pending.type,
             promise,
         };
         priorityCommandLifecycleRef.current = lifecycle;
+        setActivePriorityCommandType(pending.type);
         void promise
             .catch(() => { })
             .finally(() => {
             if (priorityCommandLifecycleRef.current === lifecycle) {
                 priorityCommandLifecycleRef.current = null;
+                setActivePriorityCommandType(null);
             }
         });
         return promise;
@@ -250,7 +262,7 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         refresh,
     ]);
     const issueCommand = useCallback(async (type, args = null) => {
-        const snapshot = snapshotRef.current;
+        let snapshot = snapshotRef.current;
         if (!snapshot) {
             throw new LocalSyncCoordinatorBrowserClientError('The local sync coordinator is not attached.', 'SYNC_COORDINATOR_UNAVAILABLE', 409);
         }
@@ -258,21 +270,54 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         if (priorityCommand) {
             const activePriority = priorityCommandLifecycleRef.current;
             if (activePriority?.workspaceId === input.workspaceId) {
-                return activePriority.promise;
+                if (activePriority.type === type)
+                    return activePriority.promise;
+                await activePriority.promise;
             }
             const resumedPriority = resumePendingPriorityCommand(scopeRef.current);
-            if (resumedPriority)
-                return resumedPriority;
+            if (resumedPriority) {
+                const resumedType = priorityCommandLifecycleRef.current?.type;
+                if (resumedType === type)
+                    return resumedPriority;
+                await resumedPriority;
+            }
         }
         const active = commandLifecycleRef.current;
-        if (!priorityCommand && active?.workspaceId === input.workspaceId) {
-            await active.promise;
+        if (active?.workspaceId === input.workspaceId) {
+            if (active.type === type)
+                return active.promise;
+            const activeIsToggle = active.type === 'EnableSync' || active.type === 'DisableSync';
+            if (!priorityCommand || activeIsToggle)
+                await active.promise;
         }
-        if (!priorityCommand) {
-            const resumed = resumePendingCommand(scopeRef.current);
-            if (resumed)
+        const resumed = resumePendingCommand(scopeRef.current);
+        if (resumed) {
+            const resumedType = commandLifecycleRef.current?.type;
+            if (resumedType === type)
+                return resumed;
+            const resumedIsToggle = resumedType === 'EnableSync' || resumedType === 'DisableSync';
+            if (!priorityCommand || resumedIsToggle)
                 await resumed;
         }
+        if (!priorityCommand) {
+            const activePriority = priorityCommandLifecycleRef.current;
+            if (activePriority?.workspaceId === input.workspaceId) {
+                if (activePriority.type === type)
+                    return activePriority.promise;
+                await activePriority.promise;
+            }
+            const resumedPriority = resumePendingPriorityCommand(scopeRef.current);
+            if (resumedPriority) {
+                const resumedType = priorityCommandLifecycleRef.current?.type;
+                if (resumedType === type)
+                    return resumedPriority;
+                await resumedPriority;
+            }
+        }
+        snapshot = snapshotRef.current;
+        if (!snapshot) {
+            throw new LocalSyncCoordinatorBrowserClientError('The local sync coordinator is not attached.', 'SYNC_COORDINATOR_UNAVAILABLE', 409);
+        }
         const envelope = {
             commandId: crypto.randomUUID(),
             workspaceId: input.workspaceId,
@@ -290,15 +335,28 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         const lifecycle = {
             workspaceId: input.workspaceId,
             scope: scopeRef.current,
+            type,
             promise: commandPromise,
         };
         const lifecycleRef = priorityCommand
             ? priorityCommandLifecycleRef
             : commandLifecycleRef;
         lifecycleRef.current = lifecycle;
+        if (priorityCommand) {
+            setActivePriorityCommandType(type);
+        }
+        else {
+            setActiveCommandType(type);
+        }
         const finalize = () => {
             if (lifecycleRef.current === lifecycle) {
                 lifecycleRef.current = null;
+                if (priorityCommand) {
+                    setActivePriorityCommandType(null);
+                }
+                else {
+                    setActiveCommandType(null);
+                }
             }
             if (scopeRef.current === lifecycle.scope
                 && input.workspaceId === lifecycle.workspaceId) {
@@ -326,6 +384,18 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         });
         return true;
     }, [client, input.workspaceId]);
+    const clearCredential = useCallback(async () => {
+        const snapshot = snapshotRef.current;
+        if (!snapshot || !input.workspaceId)
+            return false;
+        await client.clearCredential({
+            workspaceId: input.workspaceId,
+            coordinatorGeneration: snapshot.state.coordinatorGeneration,
+        });
+        snapshotRef.current = null;
+        setState({ phase: 'idle', snapshot: null, error: null });
+        return true;
+    }, [client, input.workspaceId]);
     const switchWorkspace = useCallback(async (targetWorkspaceId) => {
         const snapshot = snapshotRef.current;
         const expectedActiveWorkspaceId = String(snapshot?.state.activeWorkspaceId || '').trim();
@@ -381,12 +451,18 @@ export function useLocalSyncCoordinatorSnapshot(input) {
     }, [client, input.workspaceId, refresh]);
     return useMemo(() => ({
         ...state,
+        activeCommandType,
+        activePriorityCommandType,
         refresh,
         issueCommand,
         signalWake,
+        clearCredential,
         switchWorkspace,
         transferOwnership,
     }), [
+        activeCommandType,
+        activePriorityCommandType,
+        clearCredential,
         issueCommand,
         refresh,
         signalWake,

package/dist/hooks/sync/useSyncStatusControls.d.ts

@@ -5,21 +5,24 @@ interface SaveWorkspaceCloudSyncSettingsResult {
 interface UseSyncStatusControlsInput {
     canManageWorkspaceSync: boolean;
     workspaceCloudSyncEnabled: boolean;
+    persistedToggleIntent?: WorkspaceSyncToggleIntent;
     saveWorkspaceCloudSyncSettings: (input: {
         enabled: boolean;
     }) => Promise<SaveWorkspaceCloudSyncSettingsResult>;
 }
+export type WorkspaceSyncToggleIntent = 'enabling' | 'disabling' | null;
 interface UseSyncStatusControlsResult {
     showSyncStatusModal: boolean;
     showSyncEnableWarning: boolean;
     workspaceSyncToggleBusy: boolean;
     workspaceSyncError: string | null;
     syncControlBusy: boolean;
+    syncControlIntent: WorkspaceSyncToggleIntent;
     openSyncStatusModal: () => void;
     closeSyncStatusModal: () => void;
     handleWorkspaceSyncToggle: (enabled: boolean) => Promise<void>;
     cancelSyncEnableWarning: () => void;
     confirmSyncEnableWarning: () => void;
 }
-export declare function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, saveWorkspaceCloudSyncSettings, }: UseSyncStatusControlsInput): UseSyncStatusControlsResult;
+export declare function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, persistedToggleIntent, saveWorkspaceCloudSyncSettings, }: UseSyncStatusControlsInput): UseSyncStatusControlsResult;
 export {};

package/dist/hooks/sync/useSyncStatusControls.js

@@ -1,23 +1,58 @@
-import { useCallback, useState } from 'react';
-export function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, saveWorkspaceCloudSyncSettings, }) {
+import { useCallback, useEffect, useRef, useState } from 'react';
+export function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, persistedToggleIntent = null, saveWorkspaceCloudSyncSettings, }) {
     const [showSyncStatusModal, setShowSyncStatusModal] = useState(false);
     const [showSyncEnableWarning, setShowSyncEnableWarning] = useState(false);
     const [workspaceSyncToggleBusy, setWorkspaceSyncToggleBusy] = useState(false);
     const [workspaceSyncError, setWorkspaceSyncError] = useState(null);
+    const [requestedSyncEnabled, setRequestedSyncEnabled] = useState(null);
+    const inFlightToggleRef = useRef(null);
+    const requestedToggleIntent = requestedSyncEnabled === null
+        ? null
+        : requestedSyncEnabled ? 'enabling' : 'disabling';
+    const syncControlIntent = requestedToggleIntent || persistedToggleIntent;
+    useEffect(() => {
+        if (requestedSyncEnabled !== null && requestedSyncEnabled === workspaceCloudSyncEnabled) {
+            setRequestedSyncEnabled(null);
+        }
+    }, [requestedSyncEnabled, workspaceCloudSyncEnabled]);
     const persistWorkspaceSyncToggle = useCallback(async (enabled) => {
         if (!canManageWorkspaceSync)
             return;
         setWorkspaceSyncError(null);
+        setRequestedSyncEnabled(enabled);
         setWorkspaceSyncToggleBusy(true);
-        try {
-            const result = await saveWorkspaceCloudSyncSettings({ enabled });
-            if (!result.success) {
-                setWorkspaceSyncError(result.error || (enabled ? 'Failed to enable sync.' : 'Failed to disable sync.'));
-            }
-        }
-        finally {
-            setWorkspaceSyncToggleBusy(false);
+        while (inFlightToggleRef.current) {
+            const active = inFlightToggleRef.current;
+            if (active.enabled === enabled)
+                return active.promise;
+            await active.promise;
         }
+        setRequestedSyncEnabled(enabled);
+        setWorkspaceSyncToggleBusy(true);
+        let commandPromise;
+        commandPromise = (async () => {
+            try {
+                const result = await saveWorkspaceCloudSyncSettings({ enabled });
+                if (!result.success) {
+                    setRequestedSyncEnabled(null);
+                    setWorkspaceSyncError(result.error || (enabled ? 'Failed to enable sync.' : 'Failed to disable sync.'));
+                }
+            }
+            catch (error) {
+                setRequestedSyncEnabled(null);
+                setWorkspaceSyncError(error instanceof Error && error.message.trim()
+                    ? error.message
+                    : enabled ? 'Failed to enable sync.' : 'Failed to disable sync.');
+            }
+            finally {
+                if (inFlightToggleRef.current?.promise === commandPromise) {
+                    inFlightToggleRef.current = null;
+                    setWorkspaceSyncToggleBusy(false);
+                }
+            }
+        })();
+        inFlightToggleRef.current = { enabled, promise: commandPromise };
+        return commandPromise;
     }, [
         canManageWorkspaceSync,
         saveWorkspaceCloudSyncSettings
@@ -50,7 +85,8 @@ export function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSy
         showSyncEnableWarning,
         workspaceSyncToggleBusy,
         workspaceSyncError,
-        syncControlBusy: workspaceSyncToggleBusy,
+        syncControlBusy: workspaceSyncToggleBusy || syncControlIntent !== null,
+        syncControlIntent,
         openSyncStatusModal,
         closeSyncStatusModal,
         handleWorkspaceSyncToggle,

package/dist/hooks/useSyncOrchestrator.d.ts

@@ -79,9 +79,12 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
         phase: import("./sync/useLocalSyncCoordinatorSnapshot.js").LocalSyncCoordinatorSnapshotPhase;
         snapshot: import("../sync/coordinator/localSyncCoordinatorBrowserClient.js").LocalSyncCoordinatorStatusResponse | null;
         errorMessage: string | null;
+        activeCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
+        activePriorityCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
     } | null;
     switchLocalCoordinatorWorkspace: (targetWorkspaceId: string) => Promise<boolean>;
     transferLocalCoordinatorOwnership: (targetMode: "server" | "browser-gateway") => Promise<boolean>;
+    clearLocalCoordinatorCredential: () => Promise<boolean>;
     syncInFlightRef: import("react").RefObject<boolean>;
     workspaceRetryAt: string | null;
     isWorkspaceRetryPending: () => boolean;

package/dist/hooks/useSyncOrchestrator.js

@@ -156,6 +156,29 @@ export function useSyncOrchestrator(input) {
     const bootstrapPhaseStartedAtRef = useRef(null);
     const bootstrapLastProgressAtRef = useRef(null);
     const lastBootstrapPhaseRef = useRef('idle');
+    // Incremented every time the workspace-switch reset effect runs (including a
+    // switch back to the same workspace id). Reference-snapshot refreshes capture
+    // this value before their first await and refuse to commit a response whose
+    // generation has since moved on, so a stale/raced fetch can never overwrite a
+    // fresher (or freshly-reset) snapshot with data for the wrong workspace visit.
+    const workspaceSyncGenerationRef = useRef(0);
+    // Positive completeness signal for the document/asset snapshots, mirrored in a
+    // ref (not React state) so buildWorkspaceSyncPayload's ref-only read pattern
+    // can't observe a stale value from an earlier render's closure. Only ever set
+    // true immediately alongside a validated, non-stale successful refresh; reset
+    // to false whenever the workspace-switch effect invalidates the current
+    // generation. buildWorkspaceSyncPayloadModel refuses to compute any deletions
+    // for a domain while its completeness flag is false.
+    const workspaceSyncDocumentsSnapshotCompleteRef = useRef(false);
+    const workspaceSyncAssetsSnapshotCompleteRef = useRef(false);
+    // Per-domain monotonic request counters. Incremented at the start of every
+    // refresh call (independent of workspaceSyncGenerationRef, which only tracks
+    // workspace switches). Guards against two overlapping in-flight requests for
+    // the SAME workspace/generation — e.g. an interval tick firing while an
+    // event-triggered refresh is still in flight — where an older response could
+    // otherwise resolve after a newer one and overwrite fresher data.
+    const workspaceSyncDocumentsRequestSeqRef = useRef(0);
+    const workspaceSyncAssetsRequestSeqRef = useRef(0);
     // === SECTION: User global settings sync ===
     const clearUserSettingsRetry = useCallback(() => {
         if (userSettingsRetryTimeoutRef.current !== null) {
@@ -256,6 +279,7 @@ export function useSyncOrchestrator(input) {
     const workspaceLastPushedInitiativeWatermarksRef = useRef(new Map());
     const workspaceLastPushedWorkstreamIdsRef = useRef(new Set());
     const workspaceLastPushedWorkstreamWatermarksRef = useRef(new Map());
+    const workspaceLastPushedPlanningIdentityWatermarksRef = useRef(new Map());
     const workspaceLastPushedAiProfileIdsRef = useRef(new Set());
     const workspaceLastPushedAiProfileWatermarksRef = useRef(new Map());
     const workspaceLastPushedAiProfileChangeKeysRef = useRef(new Map());
@@ -288,6 +312,7 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushedInitiativeWatermarksRef.current = persisted.initiativeWatermarks;
         workspaceLastPushedWorkstreamIdsRef.current = new Set(Array.from(persisted.workstreamWatermarks.keys()));
         workspaceLastPushedWorkstreamWatermarksRef.current = persisted.workstreamWatermarks;
+        workspaceLastPushedPlanningIdentityWatermarksRef.current = new Map(persisted.planningIdentityWatermarks || []);
         workspaceLastPushedAiProfileIdsRef.current = new Set(Array.from(persisted.aiProfileWatermarks.keys()));
         workspaceLastPushedAiProfileWatermarksRef.current = persisted.aiProfileWatermarks;
         workspaceLastPushedAiProfileChangeKeysRef.current = persisted.aiProfileChangeKeys || new Map();
@@ -319,6 +344,7 @@ export function useSyncOrchestrator(input) {
         taxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef.current,
         initiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef.current,
         workstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef.current,
+        planningIdentityWatermarks: workspaceLastPushedPlanningIdentityWatermarksRef.current,
         aiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef.current,
         aiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef.current,
         taskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef.current,
@@ -604,6 +630,9 @@ export function useSyncOrchestrator(input) {
         taxonomyStateFingerprint
     ]);
     useEffect(() => {
+        workspaceSyncGenerationRef.current += 1;
+        workspaceSyncDocumentsSnapshotCompleteRef.current = false;
+        workspaceSyncAssetsSnapshotCompleteRef.current = false;
         workspaceSyncMarkdownDocumentsFingerprintRef.current = '';
         workspaceSyncAiProfilesFingerprintRef.current = '';
         workspaceSyncAssetsFingerprintRef.current = '';
@@ -612,11 +641,15 @@ export function useSyncOrchestrator(input) {
         workspaceSyncTaskforceAgentsFingerprintRef.current = '';
         workspaceAttachBootstrapBaselineSignatureRef.current = '';
         workspaceCaptureAttachBootstrapBaselineRef.current = false;
+        workspaceSyncMarkdownDocumentsRef.current = [];
+        workspaceSyncKnownDocumentPathsRef.current = new Set();
         setWorkspaceSyncMarkdownDocuments([]);
         setWorkspaceSyncMarkdownDocumentsFingerprint('');
         workspaceSyncAiProfilesRef.current = [];
         setWorkspaceSyncAiProfiles([]);
         setWorkspaceSyncAiProfilesFingerprint('');
+        workspaceSyncAssetsRef.current = [];
+        workspaceSyncKnownAssetPathsRef.current = new Set();
         setWorkspaceSyncAssets([]);
         setWorkspaceSyncAssetsFingerprint('');
         workspaceSyncDocumentReviewSessionsRef.current = [];
@@ -648,6 +681,7 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushedInitiativeWatermarksRef.current = new Map();
         workspaceLastPushedWorkstreamIdsRef.current = new Set();
         workspaceLastPushedWorkstreamWatermarksRef.current = new Map();
+        workspaceLastPushedPlanningIdentityWatermarksRef.current = new Map();
         workspaceLastPushedAiProfileIdsRef.current = new Set();
         workspaceLastPushedAiProfileWatermarksRef.current = new Map();
         workspaceLastPushedAiProfileChangeKeysRef.current = new Map();
@@ -806,6 +840,7 @@ export function useSyncOrchestrator(input) {
         lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef,
         lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef,
         lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef,
+        lastPushedPlanningIdentityWatermarks: workspaceLastPushedPlanningIdentityWatermarksRef,
         lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef,
         lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef,
         lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef,
@@ -937,6 +972,8 @@ export function useSyncOrchestrator(input) {
             assets: workspaceSyncAssetsRef.current,
             currentDocumentPaths: workspaceSyncKnownDocumentPathsRef.current,
             currentAssetPaths: workspaceSyncKnownAssetPathsRef.current,
+            documentsSnapshotComplete: workspaceSyncDocumentsSnapshotCompleteRef.current,
+            assetsSnapshotComplete: workspaceSyncAssetsSnapshotCompleteRef.current,
             documentReviewSessions: workspaceSyncDocumentReviewSessionsRef.current,
             documentReviewComments: workspaceSyncDocumentReviewCommentsRef.current,
             annotatedAttachmentSessions: workspaceSyncAnnotatedAttachmentSessionsRef.current,
@@ -961,6 +998,7 @@ export function useSyncOrchestrator(input) {
                 lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef.current,
                 lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef.current,
                 lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef.current,
+                lastPushedPlanningIdentityWatermarks: workspaceLastPushedPlanningIdentityWatermarksRef.current,
                 lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef.current,
                 lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef.current,
                 lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef.current,
@@ -1165,14 +1203,27 @@ export function useSyncOrchestrator(input) {
             return false;
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
             return false;
+        // See refreshWorkspaceSyncAssetsSnapshot for the snapshot-completeness contract
+        // this mirrors: only a response that still answers the CURRENT workspace visit
+        // may be committed or raise "ready".
+        const requestWorkspaceId = currentWorkspaceId;
+        const requestGeneration = workspaceSyncGenerationRef.current;
+        const requestSeq = (workspaceSyncDocumentsRequestSeqRef.current += 1);
+        const isStaleRequest = () => (requestWorkspaceId !== currentWorkspaceIdRef.current
+            || requestGeneration !== workspaceSyncGenerationRef.current
+            || requestSeq !== workspaceSyncDocumentsRequestSeqRef.current);
         try {
             const res = await fetch(`/api/taskforce/sync/workspace/documents?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
                 method: 'GET',
                 credentials: 'include'
             });
+            if (isStaleRequest())
+                return false;
             if (!res.ok)
                 return false;
             const data = await res.json();
+            if (isStaleRequest())
+                return false;
             if (!Array.isArray(data?.documents))
                 return false;
             const docs = Array.isArray(data?.documents)
@@ -1201,13 +1252,18 @@ export function useSyncOrchestrator(input) {
             const fingerprint = typeof data?.fingerprint === 'string'
                 ? data.fingerprint
                 : JSON.stringify(docs.map((entry) => `${entry.path}:${entry.updatedAt}:${entry.content.length}`).sort());
-            if (fingerprint === workspaceSyncMarkdownDocumentsFingerprintRef.current)
+            if (isStaleRequest())
+                return false;
+            if (fingerprint === workspaceSyncMarkdownDocumentsFingerprintRef.current) {
+                workspaceSyncDocumentsSnapshotCompleteRef.current = true;
                 return true;
+            }
             workspaceSyncMarkdownDocumentsFingerprintRef.current = fingerprint;
             workspaceSyncMarkdownDocumentsRef.current = docs;
             workspaceSyncKnownDocumentPathsRef.current = knownDocumentPaths;
             setWorkspaceSyncMarkdownDocuments(docs);
             setWorkspaceSyncMarkdownDocumentsFingerprint(fingerprint);
+            workspaceSyncDocumentsSnapshotCompleteRef.current = true;
             return true;
         }
         catch (error) {
@@ -1218,6 +1274,12 @@ export function useSyncOrchestrator(input) {
             return false;
         }
         finally {
+            // General push readiness intentionally stays decoupled from the strict
+            // per-domain completeness contract above: a domain that's temporarily
+            // erroring must not block ALL sync forever. What must never happen is
+            // this domain's ref/deletion-completeness being treated as trustworthy
+            // off the back of a failed or stale fetch — that's guarded above, not
+            // here. See workspaceSyncDocumentsSnapshotCompleteRef.
             markWorkspaceSyncReferenceSnapshotReady('documents');
         }
     }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, markWorkspaceSyncReferenceSnapshotReady]);
@@ -1288,14 +1350,31 @@ export function useSyncOrchestrator(input) {
             return false;
         if (cloudAuthConfigured && (!authSessionResolved || !isAuthenticated))
             return false;
+        // Snapshot-completeness contract: a response is only ever committed, and
+        // "ready" only ever raised, when it demonstrably answers the CURRENT
+        // workspace visit. Any failure, malformed payload, or response that
+        // resolves after the workspace has moved on (switched away and possibly
+        // back) is discarded outright — never coerced into "assume unchanged" or
+        // "assume empty". This is what makeWorkspaceSyncPayloadModel's delete-diff
+        // relies on via assetsSnapshotComplete.
+        const requestWorkspaceId = currentWorkspaceId;
+        const requestGeneration = workspaceSyncGenerationRef.current;
+        const requestSeq = (workspaceSyncAssetsRequestSeqRef.current += 1);
+        const isStaleRequest = () => (requestWorkspaceId !== currentWorkspaceIdRef.current
+            || requestGeneration !== workspaceSyncGenerationRef.current
+            || requestSeq !== workspaceSyncAssetsRequestSeqRef.current);
         try {
             const res = await fetch(`/api/taskforce/sync/workspace/assets?workspaceId=${encodeURIComponent(currentWorkspaceId)}`, {
                 method: 'GET',
                 credentials: 'include'
             });
+            if (isStaleRequest())
+                return false;
             if (!res.ok)
                 return false;
             const data = await res.json();
+            if (isStaleRequest())
+                return false;
             if (!Array.isArray(data?.assets))
                 return false;
             const assets = Array.isArray(data?.assets)
@@ -1328,13 +1407,18 @@ export function useSyncOrchestrator(input) {
             const fingerprint = typeof data?.fingerprint === 'string'
                 ? data.fingerprint
                 : JSON.stringify(assets.map((entry) => `${entry.path}:${entry.updatedAt}:${entry.contentBase64.length}`).sort());
-            if (fingerprint === workspaceSyncAssetsFingerprintRef.current)
+            if (isStaleRequest())
+                return false;
+            if (fingerprint === workspaceSyncAssetsFingerprintRef.current) {
+                workspaceSyncAssetsSnapshotCompleteRef.current = true;
                 return true;
+            }
             workspaceSyncAssetsFingerprintRef.current = fingerprint;
             workspaceSyncAssetsRef.current = assets;
             workspaceSyncKnownAssetPathsRef.current = knownAssetPaths;
             setWorkspaceSyncAssets(assets);
             setWorkspaceSyncAssetsFingerprint(fingerprint);
+            workspaceSyncAssetsSnapshotCompleteRef.current = true;
             return true;
         }
         catch (error) {
@@ -1345,6 +1429,8 @@ export function useSyncOrchestrator(input) {
             return false;
         }
         finally {
+            // See refreshWorkspaceSyncMarkdownDocumentsSnapshot: general push
+            // readiness stays decoupled from the strict completeness contract above.
             markWorkspaceSyncReferenceSnapshotReady('assets');
         }
     }, [runtimeMode, currentWorkspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, markWorkspaceSyncReferenceSnapshotReady]);
@@ -1622,6 +1708,16 @@ export function useSyncOrchestrator(input) {
         workspaceLastPushedWorkstreamWatermarksRef.current = new Map(workspaceWorkstreamsRef.current
             .map((entry) => [String(entry?.id || '').trim(), String(entry?.updatedAt || entry?.createdAt || '').trim()])
             .filter(([id]) => id.length > 0));
+        workspaceLastPushedPlanningIdentityWatermarksRef.current = new Map([
+            ...workspaceInitiativesRef.current.map((entry) => [
+                `initiative:${String(entry?.id || '').trim()}`,
+                String(entry?.identityUpdatedAt || '').trim(),
+            ]),
+            ...workspaceWorkstreamsRef.current.map((entry) => [
+                `workstream:${String(entry?.id || '').trim()}`,
+                String(entry?.identityUpdatedAt || '').trim(),
+            ]),
+        ].filter(([key, watermark]) => !key.endsWith(':') && Number.isFinite(Date.parse(watermark))));
         workspaceLastPushedAiProfileIdsRef.current = new Set(workspaceSyncAiProfilesRef.current
             .map((entry) => String(entry?.id || '').trim())
             .filter((id) => id.length > 0));
@@ -2636,6 +2732,8 @@ export function useSyncOrchestrator(input) {
             phase: localCoordinator.phase,
             snapshot: localCoordinator.snapshot,
             errorMessage: localCoordinator.error?.message || null,
+            activeCommandType: localCoordinator.activeCommandType,
+            activePriorityCommandType: localCoordinator.activePriorityCommandType,
         }
         : null;
     const switchLocalCoordinatorWorkspace = useCallback(async (targetWorkspaceId) => {
@@ -2677,6 +2775,16 @@ export function useSyncOrchestrator(input) {
         runtimeMode,
         workspaceCloudSyncEnabled,
     ]);
+    const clearLocalCoordinatorCredential = useCallback(async () => {
+        if (runtimeMode !== 'local'
+            || !localCoordinatorAttachmentEnabled)
+            return false;
+        return localCoordinator.clearCredential();
+    }, [
+        localCoordinator,
+        localCoordinatorAttachmentEnabled,
+        runtimeMode,
+    ]);
     return {
         userGlobalSyncStatus,
         setUserGlobalSyncStatus,
@@ -2700,6 +2808,7 @@ export function useSyncOrchestrator(input) {
         localCoordinatorStatus,
         switchLocalCoordinatorWorkspace,
         transferLocalCoordinatorOwnership,
+        clearLocalCoordinatorCredential,
         syncInFlightRef,
         workspaceRetryAt,
         isWorkspaceRetryPending,