@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/hooks/sync/useSyncStatusActions.js

@@ -0,0 +1,88 @@
+import { useCallback, useEffect, useState } from 'react';
+import { buildCopySyncDetailsText, resolveSyncStageLabel, } from '../../utils/syncStatusPresentation';
+export function useSyncStatusActions({ currentWorkspaceId, syncStatusLabel, workspaceSyncSummary, workspaceSyncRecommendedAction, formattedLastSyncTime, formattedLastPullTime, formattedLastPushTime, workspaceSyncDiagnostics, workspaceSyncPendingChanges, syncLastError, workspaceSyncPhase, referenceMismatchCount, syncRecentEvents, loadRecentSyncEvents, pushNotice, resetWorkspaceSyncCursorAndPull, workspaceSyncBusy, }) {
+    const [workspaceSyncRepairBusy, setWorkspaceSyncRepairBusy] = useState(false);
+    const [workspaceSyncRepairQueued, setWorkspaceSyncRepairQueued] = useState(false);
+    const [workspaceSyncCopied, setWorkspaceSyncCopied] = useState(false);
+    const handleCopySyncDetails = useCallback(async () => {
+        try {
+            const events = syncRecentEvents.length > 0 ? syncRecentEvents : await loadRecentSyncEvents();
+            const copyText = buildCopySyncDetailsText({
+                currentWorkspaceId,
+                syncStatusLabel,
+                workspaceSyncSummary,
+                workspaceSyncRecommendedAction,
+                formattedLastSyncTime,
+                formattedLastPullTime,
+                formattedLastPushTime,
+                workspaceSyncDiagnostics,
+                workspaceSyncPendingChanges,
+                syncLastError,
+                syncStageLabel: resolveSyncStageLabel(workspaceSyncPhase, workspaceSyncRepairBusy, workspaceSyncBusy),
+                referenceMismatchCount,
+                syncRecentEvents: events
+            });
+            await navigator.clipboard.writeText(copyText);
+            setWorkspaceSyncCopied(true);
+            window.setTimeout(() => {
+                setWorkspaceSyncCopied(false);
+            }, 1800);
+            pushNotice('Sync details copied to clipboard.', 'success');
+        }
+        catch {
+            setWorkspaceSyncCopied(false);
+            pushNotice('Failed to copy sync details.', 'error');
+        }
+    }, [
+        currentWorkspaceId,
+        formattedLastPullTime,
+        formattedLastPushTime,
+        formattedLastSyncTime,
+        loadRecentSyncEvents,
+        pushNotice,
+        referenceMismatchCount,
+        syncLastError,
+        syncRecentEvents,
+        syncStatusLabel,
+        workspaceSyncDiagnostics,
+        workspaceSyncPhase,
+        workspaceSyncPendingChanges,
+        workspaceSyncRecommendedAction,
+        workspaceSyncSummary,
+        workspaceSyncBusy,
+        workspaceSyncRepairBusy,
+    ]);
+    const handleRepairSync = useCallback(async () => {
+        setWorkspaceSyncRepairQueued(false);
+        setWorkspaceSyncRepairBusy(true);
+        try {
+            await resetWorkspaceSyncCursorAndPull();
+        }
+        finally {
+            setWorkspaceSyncRepairBusy(false);
+        }
+    }, [resetWorkspaceSyncCursorAndPull]);
+    const handleQueueOrRunRepairSync = useCallback(() => {
+        if (workspaceSyncRepairBusy)
+            return;
+        if (workspaceSyncBusy) {
+            setWorkspaceSyncRepairQueued(true);
+            return;
+        }
+        void handleRepairSync();
+    }, [handleRepairSync, workspaceSyncBusy, workspaceSyncRepairBusy]);
+    useEffect(() => {
+        if (!workspaceSyncRepairQueued)
+            return;
+        if (workspaceSyncBusy || workspaceSyncRepairBusy)
+            return;
+        void handleRepairSync();
+    }, [handleRepairSync, workspaceSyncBusy, workspaceSyncRepairBusy, workspaceSyncRepairQueued]);
+    return {
+        workspaceSyncRepairBusy,
+        workspaceSyncRepairQueued,
+        workspaceSyncCopied,
+        handleCopySyncDetails,
+        handleQueueOrRunRepairSync,
+    };
+}

package/dist/hooks/sync/useSyncStatusActions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/sync/useSyncStatusActions.test.js

@@ -0,0 +1,133 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useSyncStatusActions } from './useSyncStatusActions';
+function makeInput(overrides) {
+    return {
+        currentWorkspaceId: 'workspace-1',
+        syncStatusLabel: 'Healthy',
+        workspaceSyncSummary: 'Sync is healthy.',
+        workspaceSyncRecommendedAction: 'No action needed.',
+        formattedLastSyncTime: '4/17/2026, 10:32:47 PM',
+        formattedLastPullTime: '4/17/2026, 10:32:47 PM',
+        formattedLastPushTime: '4/17/2026, 10:31:45 PM',
+        workspaceSyncDiagnostics: {
+            aiProfileSnapshotCount: 1,
+            aiProfileSnapshotRawCount: 1,
+            lastPushedAiProfileCount: 1,
+            lastPushedAiProfileWatermarkCount: 1,
+            documentSnapshotCount: 2,
+            assetSnapshotCount: 3,
+            forceFullAiProfilePushQueued: false,
+        },
+        workspaceSyncPendingChanges: 4,
+        syncLastError: 'None',
+        workspaceSyncPhase: 'active',
+        referenceMismatchCount: 0,
+        syncRecentEvents: [],
+        loadRecentSyncEvents: vi.fn(async () => [{
+                occurredAt: '2026-04-18T01:33:06.044Z',
+                eventType: 'apply',
+                status: 'success',
+                changeCount: 200,
+                requestMs: 167,
+                statusCode: 0,
+            }]),
+        pushNotice: vi.fn(),
+        resetWorkspaceSyncCursorAndPull: vi.fn(async () => undefined),
+        workspaceSyncBusy: false,
+        ...overrides,
+    };
+}
+describe('useSyncStatusActions', () => {
+    beforeEach(() => {
+        vi.stubGlobal('navigator', {
+            clipboard: {
+                writeText: vi.fn(async () => undefined),
+            },
+        });
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.unstubAllGlobals();
+    });
+    it('copies the sync report using freshly loaded events when needed', async () => {
+        vi.useFakeTimers();
+        const input = makeInput();
+        const { result } = renderHook(() => useSyncStatusActions(input));
+        await act(async () => {
+            await result.current.handleCopySyncDetails();
+        });
+        expect(input.loadRecentSyncEvents).toHaveBeenCalledTimes(1);
+        expect(navigator.clipboard.writeText).toHaveBeenCalledWith(expect.stringContaining('Taskforce Sync Manager'));
+        expect(input.pushNotice).toHaveBeenCalledWith('Sync details copied to clipboard.', 'success');
+        expect(result.current.workspaceSyncCopied).toBe(true);
+        act(() => {
+            vi.advanceTimersByTime(1800);
+        });
+        expect(result.current.workspaceSyncCopied).toBe(false);
+    });
+    it('uses the current in-memory events instead of reloading when available', async () => {
+        const input = makeInput({
+            syncRecentEvents: [{
+                    occurredAt: '2026-04-18T01:33:18.371Z',
+                    eventType: 'apply',
+                    status: 'success',
+                    changeCount: 200,
+                    requestMs: 87,
+                    statusCode: 0,
+                }],
+        });
+        const { result } = renderHook(() => useSyncStatusActions(input));
+        await act(async () => {
+            await result.current.handleCopySyncDetails();
+        });
+        expect(input.loadRecentSyncEvents).not.toHaveBeenCalled();
+        expect(navigator.clipboard.writeText).toHaveBeenCalledWith(expect.stringContaining('2026-04-18T01:33:18.371Z apply succeeded'));
+    });
+    it('surfaces copy failures as an error notice', async () => {
+        const writeText = vi.fn(async () => {
+            throw new Error('clipboard unavailable');
+        });
+        vi.stubGlobal('navigator', {
+            clipboard: { writeText },
+        });
+        const input = makeInput();
+        const { result } = renderHook(() => useSyncStatusActions(input));
+        await act(async () => {
+            await result.current.handleCopySyncDetails();
+        });
+        expect(result.current.workspaceSyncCopied).toBe(false);
+        expect(input.pushNotice).toHaveBeenCalledWith('Failed to copy sync details.', 'error');
+    });
+    it('queues repair while sync is busy and runs it once the workspace becomes idle', async () => {
+        const input = makeInput({
+            workspaceSyncBusy: true,
+        });
+        const { result, rerender } = renderHook((props) => useSyncStatusActions(props), {
+            initialProps: input,
+        });
+        act(() => {
+            result.current.handleQueueOrRunRepairSync();
+        });
+        expect(result.current.workspaceSyncRepairQueued).toBe(true);
+        expect(input.resetWorkspaceSyncCursorAndPull).not.toHaveBeenCalled();
+        rerender({
+            ...input,
+            workspaceSyncBusy: false,
+        });
+        await waitFor(() => {
+            expect(input.resetWorkspaceSyncCursorAndPull).toHaveBeenCalledTimes(1);
+        });
+        expect(result.current.workspaceSyncRepairQueued).toBe(false);
+    });
+    it('runs repair immediately when the workspace is already idle', async () => {
+        const input = makeInput();
+        const { result } = renderHook(() => useSyncStatusActions(input));
+        act(() => {
+            result.current.handleQueueOrRunRepairSync();
+        });
+        await waitFor(() => {
+            expect(input.resetWorkspaceSyncCursorAndPull).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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

@@ -0,0 +1,25 @@
+interface SaveWorkspaceCloudSyncSettingsResult {
+    success: boolean;
+    error?: string | null;
+}
+interface UseSyncStatusControlsInput {
+    canManageWorkspaceSync: boolean;
+    workspaceCloudSyncEnabled: boolean;
+    saveWorkspaceCloudSyncSettings: (input: {
+        enabled: boolean;
+    }) => Promise<SaveWorkspaceCloudSyncSettingsResult>;
+}
+interface UseSyncStatusControlsResult {
+    showSyncStatusModal: boolean;
+    showSyncEnableWarning: boolean;
+    workspaceSyncToggleBusy: boolean;
+    workspaceSyncError: string | null;
+    syncControlBusy: boolean;
+    openSyncStatusModal: () => void;
+    closeSyncStatusModal: () => void;
+    handleWorkspaceSyncToggle: (enabled: boolean) => Promise<void>;
+    cancelSyncEnableWarning: () => void;
+    confirmSyncEnableWarning: () => void;
+}
+export declare function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, saveWorkspaceCloudSyncSettings, }: UseSyncStatusControlsInput): UseSyncStatusControlsResult;
+export {};

package/dist/hooks/sync/useSyncStatusControls.js

@@ -0,0 +1,60 @@
+import { useCallback, useState } from 'react';
+export function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, saveWorkspaceCloudSyncSettings, }) {
+    const [showSyncStatusModal, setShowSyncStatusModal] = useState(false);
+    const [showSyncEnableWarning, setShowSyncEnableWarning] = useState(false);
+    const [workspaceSyncToggleBusy, setWorkspaceSyncToggleBusy] = useState(false);
+    const [workspaceSyncError, setWorkspaceSyncError] = useState(null);
+    const persistWorkspaceSyncToggle = useCallback(async (enabled) => {
+        if (!canManageWorkspaceSync)
+            return;
+        setWorkspaceSyncError(null);
+        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);
+        }
+    }, [
+        canManageWorkspaceSync,
+        saveWorkspaceCloudSyncSettings
+    ]);
+    const handleWorkspaceSyncToggle = useCallback(async (enabled) => {
+        if (enabled && !workspaceCloudSyncEnabled) {
+            setShowSyncEnableWarning(true);
+            return;
+        }
+        await persistWorkspaceSyncToggle(enabled);
+    }, [
+        persistWorkspaceSyncToggle,
+        workspaceCloudSyncEnabled
+    ]);
+    const cancelSyncEnableWarning = useCallback(() => {
+        setShowSyncEnableWarning(false);
+    }, []);
+    const confirmSyncEnableWarning = useCallback(() => {
+        setShowSyncEnableWarning(false);
+        void persistWorkspaceSyncToggle(true);
+    }, [persistWorkspaceSyncToggle]);
+    const openSyncStatusModal = useCallback(() => {
+        setShowSyncStatusModal(true);
+    }, []);
+    const closeSyncStatusModal = useCallback(() => {
+        setShowSyncStatusModal(false);
+    }, []);
+    return {
+        showSyncStatusModal,
+        showSyncEnableWarning,
+        workspaceSyncToggleBusy,
+        workspaceSyncError,
+        syncControlBusy: workspaceSyncToggleBusy,
+        openSyncStatusModal,
+        closeSyncStatusModal,
+        handleWorkspaceSyncToggle,
+        cancelSyncEnableWarning,
+        confirmSyncEnableWarning,
+    };
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/hooks/sync/useSyncStatusControls.test.js

@@ -0,0 +1,88 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import { useSyncStatusControls } from './useSyncStatusControls';
+function makeInput(overrides) {
+    return {
+        canManageWorkspaceSync: true,
+        workspaceCloudSyncEnabled: false,
+        saveWorkspaceCloudSyncSettings: vi.fn(async () => ({ success: true })),
+        ...overrides,
+    };
+}
+describe('useSyncStatusControls', () => {
+    it('opens and closes the sync status modal', () => {
+        const { result } = renderHook(() => useSyncStatusControls(makeInput()));
+        act(() => {
+            result.current.openSyncStatusModal();
+        });
+        expect(result.current.showSyncStatusModal).toBe(true);
+        act(() => {
+            result.current.closeSyncStatusModal();
+        });
+        expect(result.current.showSyncStatusModal).toBe(false);
+    });
+    it('shows the warning before enabling sync from a local-only workspace', async () => {
+        const input = makeInput({
+            workspaceCloudSyncEnabled: false,
+        });
+        const { result } = renderHook(() => useSyncStatusControls(input));
+        await act(async () => {
+            await result.current.handleWorkspaceSyncToggle(true);
+        });
+        expect(result.current.showSyncEnableWarning).toBe(true);
+        expect(input.saveWorkspaceCloudSyncSettings).not.toHaveBeenCalled();
+    });
+    it('confirms the warning and then persists enabling sync', async () => {
+        const input = makeInput({
+            workspaceCloudSyncEnabled: false,
+        });
+        const { result } = renderHook(() => useSyncStatusControls(input));
+        await act(async () => {
+            await result.current.handleWorkspaceSyncToggle(true);
+        });
+        act(() => {
+            result.current.confirmSyncEnableWarning();
+        });
+        await waitFor(() => {
+            expect(input.saveWorkspaceCloudSyncSettings).toHaveBeenCalledWith({ enabled: true });
+        });
+        expect(result.current.showSyncEnableWarning).toBe(false);
+    });
+    it('disables sync immediately without showing the warning', async () => {
+        const input = makeInput({
+            workspaceCloudSyncEnabled: true,
+        });
+        const { result } = renderHook(() => useSyncStatusControls(input));
+        await act(async () => {
+            await result.current.handleWorkspaceSyncToggle(false);
+        });
+        expect(result.current.showSyncEnableWarning).toBe(false);
+        expect(input.saveWorkspaceCloudSyncSettings).toHaveBeenCalledWith({ enabled: false });
+    });
+    it('stores toggle errors from failed sync setting updates', async () => {
+        const input = makeInput({
+            workspaceCloudSyncEnabled: true,
+            saveWorkspaceCloudSyncSettings: vi.fn(async () => ({
+                success: false,
+                error: 'Cloud sync settings could not be updated.',
+            })),
+        });
+        const { result } = renderHook(() => useSyncStatusControls(input));
+        await act(async () => {
+            await result.current.handleWorkspaceSyncToggle(false);
+        });
+        expect(result.current.workspaceSyncError).toBe('Cloud sync settings could not be updated.');
+        expect(result.current.syncControlBusy).toBe(false);
+    });
+    it('does not persist sync settings when sync controls are unavailable', async () => {
+        const input = makeInput({
+            canManageWorkspaceSync: false,
+            workspaceCloudSyncEnabled: true,
+        });
+        const { result } = renderHook(() => useSyncStatusControls(input));
+        await act(async () => {
+            await result.current.handleWorkspaceSyncToggle(false);
+        });
+        expect(input.saveWorkspaceCloudSyncSettings).not.toHaveBeenCalled();
+    });
+});

package/dist/hooks/useSyncOrchestrator.aiProfiles.test.js

@@ -15,7 +15,13 @@ describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
             provider: 'OpenAI',
             model: 'gpt-5.4',
             surface_type: 'coding_tool',
+            seat_scope: 'cloud_metered',
             provider_metadata: { source: 'test' },
+            archived_at: '2026-03-16T18:00:00.000Z',
+            archived_by: 'owner-1',
+            archived_reason: 'manual_archive',
+            merged_into_profile_id: 'ai-profile-keeper',
+            roster_state_updated_at: '2026-03-16T18:00:00.000Z',
             created_at: '2026-03-15T18:00:00.000Z',
             updated_at: '2026-03-15T18:30:00.000Z',
             last_active_at: '2026-03-15T18:45:00.000Z'
@@ -33,7 +39,13 @@ describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
             provider: 'OpenAI',
             model: 'gpt-5.4',
             surfaceType: 'coding_tool',
+            seatScope: 'cloud_metered',
             providerMetadata: { source: 'test' },
+            archivedAt: '2026-03-16T18:00:00.000Z',
+            archivedBy: 'owner-1',
+            archivedReason: 'manual_archive',
+            mergedIntoProfileId: 'ai-profile-keeper',
+            rosterStateUpdatedAt: '2026-03-16T18:00:00.000Z',
             createdAt: '2026-03-15T18:00:00.000Z',
             updatedAt: '2026-03-15T18:30:00.000Z',
             lastActiveAt: '2026-03-15T18:45:00.000Z'

package/dist/hooks/useSyncOrchestrator.d.ts

@@ -1,5 +1,5 @@
-import type { InitiativeItem, TaskItem, TaskforceTheme, WorkstreamItem } from '../types';
-import { type WorkspaceSyncPhase } from '../sync/workspaceSyncState';
+import type { DeletedTaskRecord, InitiativeItem, TaskItem, TaskforceTheme, WorkstreamItem } from '../types';
+import { type WorkspaceSyncPhase, type WorkspaceSyncSetupIntent } from '../sync/workspaceSyncState';
 import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
 import type { SupportedLocale } from '../localization';
 import { normalizeWorkspaceSyncAiProfileSnapshotEntry } from './sync/orchestratorShared';
@@ -16,6 +16,7 @@ export interface UseSyncOrchestratorInput {
     realtimeSyncEnabled: boolean;
     tasks: TaskItem[];
     archivedTasks: TaskItem[];
+    deletedTasks?: DeletedTaskRecord[];
     initiatives: InitiativeItem[];
     workstreams: WorkstreamItem[];
     taxonomies: unknown[];
@@ -42,8 +43,8 @@ export interface UseSyncOrchestratorInput {
 export type WorkspaceSyncStatus = 'off' | 'syncing' | 'attention' | 'healthy';
 export { normalizeWorkspaceSyncAiProfileSnapshotEntry };
 export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
-    userGlobalSyncStatus: "error" | "idle" | "disconnected" | "syncing";
-    setUserGlobalSyncStatus: import("react").Dispatch<import("react").SetStateAction<"error" | "idle" | "disconnected" | "syncing">>;
+    userGlobalSyncStatus: "error" | "idle" | "syncing" | "disconnected";
+    setUserGlobalSyncStatus: import("react").Dispatch<import("react").SetStateAction<"error" | "idle" | "syncing" | "disconnected">>;
     userGlobalSyncError: string | null;
     setUserGlobalSyncError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
     workspaceLastPullAt: string | null;
@@ -53,6 +54,7 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
     workspaceLastSuccessfulSyncAt: string | null;
     workspaceCloudSyncEnabled: boolean;
     workspaceSyncPhase: WorkspaceSyncPhase;
+    workspaceSyncSetupIntent: WorkspaceSyncSetupIntent;
     workspaceSyncStatus: WorkspaceSyncStatus;
     workspaceSyncSummary: string;
     workspaceSyncRecommendedAction: string;
@@ -67,14 +69,15 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
     workspacePendingSignatureRef: import("react").RefObject<string>;
     workspaceLastPushedTaskIdsRef: import("react").RefObject<Set<string>>;
     workspaceDeletedTaskIdsRef: import("react").RefObject<Set<string>>;
+    workspaceDeletedTaskWatermarksRef: import("react").RefObject<Map<string, string>>;
     workspacePullCursorRef: import("react").RefObject<string | null>;
     clearWorkspaceRetry: () => void;
     persistWorkspaceSyncPatch: (patch: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2>) => Promise<import("../sync/workspaceSyncState").WorkspaceSyncStateV2>;
     loadWorkspaceSyncState: () => Promise<void>;
-    applyWorkspaceSyncStateSnapshot: (nextState: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2> & {
+    applyWorkspaceSyncStateSnapshot: (nextState: Parameters<(nextState: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2> & {
         enabled: boolean;
         phase?: WorkspaceSyncPhase | null;
-    }) => void;
+    }) => void>[0]) => void;
     syncUserGlobalSettings: (options?: {
         preferCloudOnFirstSync?: boolean;
     }) => Promise<void>;
@@ -109,6 +112,13 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
         pendingChanges: number;
         lastErrorMessage: string | null;
         recommendedAction: string;
+        pushBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        pullBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        retryBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        repairActive: boolean;
+        pushInFlight: boolean;
+        pullInFlight: boolean;
+        retryPending: boolean;
         documentSnapshotCount: number;
         aiProfileSnapshotCount: number;
         aiProfileSnapshotRawCount: number;