@taskforcehq/taskforce 0.3.302 → 0.3.304

package/dist/hooks/ui/useResourceExport.js

@@ -1,11 +1,12 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
-export function useResourceExport({ storagePath }) {
+export function useResourceExport({ storagePath, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls }) {
     const [exportEnvironment, setExportEnvironment] = useState('antigravity');
     const [availableEnvironments, setAvailableEnvironments] = useState([]);
     const [exportWorkflowsPath, setExportWorkflowsPath] = useState('.agent/workflows');
     const [exportingResource, setExportingResource] = useState(null);
     const [exportResult, setExportResult] = useState(null);
     const exportResultTimerRef = useRef(null);
+    const shouldSkipProtectedApiCalls = shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls;
     useEffect(() => {
         const env = availableEnvironments.find((item) => item.id === exportEnvironment);
         if (env) {
@@ -23,13 +24,15 @@ export function useResourceExport({ storagePath }) {
         }, 5000);
     }, []);
     const loadAvailableEnvironments = useCallback(async () => {
+        if (shouldSkipProtectedApiCalls)
+            return;
         const envRes = await fetch('/api/taskforce/environments');
         if (!envRes.ok)
             return;
         const envData = await envRes.json().catch(() => ({}));
         if (envData.environments)
             setAvailableEnvironments(envData.environments);
-    }, []);
+    }, [shouldSkipProtectedApiCalls]);
     const handleExportWorkflows = useCallback(async (environment, selected) => {
         setExportingResource('workflows');
         setExportResult(null);

package/dist/hooks/ui/useWorkflowTemplates.js

@@ -2,8 +2,9 @@ import { useCallback, useState } from 'react';
 export function useWorkflowTemplates({ shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls }) {
     const [availableWorkflows, setAvailableWorkflows] = useState([]);
     const [initiativeTemplates, setInitiativeTemplates] = useState([]);
+    const shouldSkipProtectedApiCalls = shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls;
     const fetchWorkflows = useCallback(async () => {
-        if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls)
+        if (shouldSkipProtectedApiCalls)
             return;
         try {
             const res = await fetch('/api/taskforce/workflow-templates');
@@ -15,8 +16,10 @@ export function useWorkflowTemplates({ shouldDeferProtectedApiCalls, shouldBlock
         catch {
             // Ignore error
         }
-    }, [shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    }, [shouldSkipProtectedApiCalls]);
     const fetchInitiativeTemplates = useCallback(async () => {
+        if (shouldSkipProtectedApiCalls)
+            return [];
         try {
             const res = await fetch('/api/taskforce/initiative-templates');
             if (!res.ok)
@@ -29,9 +32,9 @@ export function useWorkflowTemplates({ shouldDeferProtectedApiCalls, shouldBlock
         catch {
             return [];
         }
-    }, []);
+    }, [shouldSkipProtectedApiCalls]);
     const fetchWorkflowTemplate = useCallback(async (name) => {
-        if (!name)
+        if (!name || shouldSkipProtectedApiCalls)
             return null;
         const paths = [
             `/api/taskforce/workflow-template/${encodeURIComponent(name)}`,
@@ -51,8 +54,10 @@ export function useWorkflowTemplates({ shouldDeferProtectedApiCalls, shouldBlock
         catch {
             return null;
         }
-    }, []);
+    }, [shouldSkipProtectedApiCalls]);
     const fetchWorkflowOverrideNames = useCallback(async () => {
+        if (shouldSkipProtectedApiCalls)
+            return [];
         try {
             const res = await fetch('/api/taskforce/workflow-editor/overrides');
             if (!res.ok)
@@ -63,7 +68,7 @@ export function useWorkflowTemplates({ shouldDeferProtectedApiCalls, shouldBlock
         catch {
             return [];
         }
-    }, []);
+    }, [shouldSkipProtectedApiCalls]);
     const saveWorkflowTemplateDraft = useCallback(async (name, draft) => {
         try {
             const res = await fetch('/api/taskforce/workflow-editor/save', {

package/dist/hooks/useRealtimeSync.js

@@ -168,7 +168,8 @@ export function useRealtimeSync(input) {
                 if (event.type === 'taskforce:update') {
                     queueSignal({
                         type: 'taskforce:update',
-                        workspaceId: normalizedWorkspaceId
+                        workspaceId: normalizedWorkspaceId,
+                        eventId: typeof event.eventId === 'string' ? event.eventId.trim() : undefined
                     });
                     return;
                 }

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

@@ -10,6 +10,10 @@ describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
             username: 'codex',
             icon: 'Bot',
             color: '#0ea5e9',
+            description: 'Terminal-first coding agent',
+            role: 'Implementer',
+            provider: 'OpenAI',
+            model: 'gpt-5.4',
             surface_type: 'coding_tool',
             provider_metadata: { source: 'test' },
             created_at: '2026-03-15T18:00:00.000Z',
@@ -24,6 +28,10 @@ describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
             username: 'codex',
             icon: 'Bot',
             color: '#0ea5e9',
+            description: 'Terminal-first coding agent',
+            role: 'Implementer',
+            provider: 'OpenAI',
+            model: 'gpt-5.4',
             surfaceType: 'coding_tool',
             providerMetadata: { source: 'test' },
             createdAt: '2026-03-15T18:00:00.000Z',

package/dist/hooks/useSyncOrchestrator.context-assets.test.d.ts

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

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 { 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;
@@ -41,9 +40,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;
@@ -85,6 +85,7 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
     }) => Promise<boolean>;
     pullWorkspaceChangesFromCloud: (options?: {
         repairMode?: boolean;
+        forceCursorNull?: boolean;
     }) => Promise<boolean>;
     saveWorkspaceCloudSyncSettings: (settings: {
         enabled: boolean;