@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/hooks/useSyncOrchestrator.context-assets.test.js

@@ -0,0 +1,228 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useSyncOrchestrator } from './useSyncOrchestrator';
+const { ensureCloudWorkspaceReadyForSyncServiceMock, runWorkspacePullSyncServiceMock, runWorkspacePushSyncServiceMock, syncUserGlobalSettingsServiceMock } = vi.hoisted(() => ({
+    ensureCloudWorkspaceReadyForSyncServiceMock: vi.fn(),
+    runWorkspacePullSyncServiceMock: vi.fn(),
+    runWorkspacePushSyncServiceMock: vi.fn(),
+    syncUserGlobalSettingsServiceMock: vi.fn()
+}));
+vi.mock('../sync/syncService', async () => {
+    const actual = await vi.importActual('../sync/syncService');
+    return {
+        ...actual,
+        calculateWorkspaceRetryDelayMs: vi.fn(() => 100),
+        ensureCloudWorkspaceReadyForSyncService: ensureCloudWorkspaceReadyForSyncServiceMock,
+        runWorkspacePullSyncService: runWorkspacePullSyncServiceMock,
+        runWorkspacePushSyncService: runWorkspacePushSyncServiceMock,
+        syncUserGlobalSettingsService: syncUserGlobalSettingsServiceMock
+    };
+});
+function buildInput(overrides) {
+    return {
+        currentWorkspaceId: 'workspace-local-active',
+        cloudAuthConfigured: true,
+        runtimeMode: 'local',
+        authSessionResolved: true,
+        isAuthenticated: true,
+        authUserId: 'user-1',
+        projectName: 'Test Project',
+        resolveCloudAuthUrl: (path) => `https://cloud.example.com${path}`,
+        resolveWebSocketUrl: (path) => `wss://api.example.com${path}`,
+        realtimeSyncEnabled: false,
+        tasks: [],
+        archivedTasks: [],
+        initiatives: [],
+        workstreams: [],
+        taxonomies: [],
+        setupState: null,
+        globalTheme: 'dark',
+        locale: 'en-US',
+        globalWeekStartsOn: 'monday',
+        themeUseGlobalDefault: true,
+        setTasks: vi.fn(),
+        setArchivedTasks: vi.fn(),
+        setAuthBlocked: vi.fn(),
+        setIsAuthenticated: vi.fn(),
+        checkAuthSession: vi.fn(async () => true),
+        setGlobalTheme: vi.fn(),
+        setCurrentTheme: vi.fn(),
+        setSetupState: vi.fn(),
+        setLocale: vi.fn(),
+        setGlobalWeekStartsOn: vi.fn(),
+        fetchPlanningEntities: vi.fn(async () => { }),
+        ...overrides
+    };
+}
+describe('useSyncOrchestrator context asset refreshes', () => {
+    beforeEach(() => {
+        ensureCloudWorkspaceReadyForSyncServiceMock.mockReset();
+        runWorkspacePullSyncServiceMock.mockReset();
+        runWorkspacePushSyncServiceMock.mockReset();
+        syncUserGlobalSettingsServiceMock.mockReset();
+        ensureCloudWorkspaceReadyForSyncServiceMock.mockResolvedValue({ success: true });
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T18:00:00.000Z',
+            cursor: null,
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T18:00:00.000Z',
+            requestMs: 1,
+            changeCount: 0,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            currentDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentDocumentReviewCommentIds: new Set(),
+            currentDocumentReviewCommentWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            currentTaskEventWatermarks: new Map(),
+            deleteTaskIds: new Set(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: []
+        });
+        syncUserGlobalSettingsServiceMock.mockResolvedValue({
+            success: true,
+            mode: 'pulled',
+            updatedAt: new Date().toISOString()
+        });
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.clearAllMocks();
+    });
+    it('refreshes only document and asset snapshots when task attachments change', async () => {
+        const fetchCounts = {
+            documents: 0,
+            assets: 0,
+            aiProfiles: 0,
+            documentReviews: 0,
+            annotatedAttachments: 0
+        };
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'active',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/documents')) {
+                fetchCounts.documents += 1;
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/assets')) {
+                fetchCounts.assets += 1;
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ assets: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/ai-profiles')) {
+                fetchCounts.aiProfiles += 1;
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ aiProfiles: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/document-reviews')) {
+                fetchCounts.documentReviews += 1;
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [], comments: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments')) {
+                fetchCounts.annotatedAttachments += 1;
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/events')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }));
+        const baseTask = {
+            id: 'task-with-attachments',
+            title: 'Task with attachment refreshes',
+            description: '',
+            category: 'general',
+            type: 'task',
+            priority: 2,
+            complexity: 3,
+            status: 'task',
+            createdAt: '2026-03-15T12:00:00.000Z',
+            updatedAt: '2026-03-15T12:00:00.000Z',
+            attachments: [],
+            taskEvents: []
+        };
+        const initialInput = buildInput({
+            tasks: [baseTask]
+        });
+        const { result, rerender, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: initialInput
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await waitFor(() => {
+            expect(fetchCounts.documents).toBeGreaterThan(0);
+            expect(fetchCounts.assets).toBeGreaterThan(0);
+            expect(fetchCounts.aiProfiles).toBeGreaterThan(0);
+            expect(fetchCounts.documentReviews).toBeGreaterThan(0);
+        });
+        const baselineCounts = { ...fetchCounts };
+        rerender({
+            ...initialInput,
+            tasks: [{
+                    ...baseTask,
+                    attachments: [{
+                            id: 'asset-1',
+                            path: 'workspaces/workspace-local-active/assets/file.txt'
+                        }]
+                }]
+        });
+        await waitFor(() => {
+            expect(fetchCounts.documents).toBeGreaterThan(baselineCounts.documents);
+            expect(fetchCounts.assets).toBeGreaterThan(baselineCounts.assets);
+        });
+        expect(fetchCounts.aiProfiles).toBe(baselineCounts.aiProfiles);
+        expect(fetchCounts.documentReviews).toBe(baselineCounts.documentReviews);
+        expect(fetchCounts.annotatedAttachments).toBe(baselineCounts.annotatedAttachments);
+        unmount();
+    });
+});

package/dist/hooks/useSyncOrchestrator.d.ts

@@ -1,9 +1,8 @@
-import type { InitiativeItem, TaskItem, TaskforceTheme, WorkstreamItem } from '../types';
-import { type WorkspaceSyncPhase } from '../sync/workspaceSyncState';
-import { type WorkspaceSyncAiProfileSnapshot } from '../sync/workspaceSyncModel';
+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';
-export declare function normalizeWorkspaceSyncAiProfileSnapshotEntry(entry: any): WorkspaceSyncAiProfileSnapshot;
+import { normalizeWorkspaceSyncAiProfileSnapshotEntry } from './sync/orchestratorShared';
 export interface UseSyncOrchestratorInput {
     currentWorkspaceId: string;
     cloudAuthConfigured: boolean;
@@ -17,6 +16,7 @@ export interface UseSyncOrchestratorInput {
     realtimeSyncEnabled: boolean;
     tasks: TaskItem[];
     archivedTasks: TaskItem[];
+    deletedTasks?: DeletedTaskRecord[];
     initiatives: InitiativeItem[];
     workstreams: WorkstreamItem[];
     taxonomies: unknown[];
@@ -41,9 +41,10 @@ export interface UseSyncOrchestratorInput {
     fetchPlanningEntities: () => Promise<void>;
 }
 export type WorkspaceSyncStatus = 'off' | 'syncing' | 'attention' | 'healthy';
+export { normalizeWorkspaceSyncAiProfileSnapshotEntry };
 export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
-    userGlobalSyncStatus: "error" | "idle" | "syncing" | "disconnected";
-    setUserGlobalSyncStatus: import("react").Dispatch<import("react").SetStateAction<"error" | "idle" | "syncing" | "disconnected">>;
+    userGlobalSyncStatus: "error" | "idle" | "disconnected" | "syncing";
+    setUserGlobalSyncStatus: import("react").Dispatch<import("react").SetStateAction<"error" | "idle" | "disconnected" | "syncing">>;
     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>;
@@ -85,6 +88,7 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
     }) => Promise<boolean>;
     pullWorkspaceChangesFromCloud: (options?: {
         repairMode?: boolean;
+        forceCursorNull?: boolean;
     }) => Promise<boolean>;
     saveWorkspaceCloudSyncSettings: (settings: {
         enabled: boolean;