@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/core/types.d.ts

@@ -15,6 +15,7 @@
 import type { DatabaseProvider } from '../storage/databaseAdapter.js';
 export type { TaskforceTheme } from '../utils/theme.js';
 import type { TaskforceTheme } from '../utils/theme.js';
+import type { InternalUserFeatureKey } from '../shared/userFeatureGrants.js';
 export interface Comment {
     id: string;
     author: string;
@@ -176,6 +177,12 @@ export interface TaskFile {
         jsonBackupEnabled?: boolean;
         manualComplexityEnabled?: boolean;
         checklistDropdownEnabled?: boolean;
+        showTaskCardStatusLabel?: boolean;
+        showTaskCardDescription?: boolean;
+        showTaskCardAttachments?: boolean;
+        showTaskCardChecklistProgress?: boolean;
+        showTaskCardLatestActivity?: boolean;
+        tintTaskCardActivityBackground?: boolean;
         taxonomies?: any[];
     };
 }
@@ -338,6 +345,7 @@ export type SystemRole = 'system_admin' | 'user';
 export type PermissionMode = 'read-only' | 'read-write';
 export type AuthTokenPurpose = 'email_verification' | 'password_reset' | 'invite_accept';
 export type McpAccessTokenScope = 'tasks:read' | 'tasks:write' | 'workspace:read';
+export type McpCloudToolProfile = 'default' | 'extended';
 export type UserAuthProvider = 'password' | 'google' | 'github' | 'apple';
 export interface UserAuthIdentity {
     id: string;
@@ -411,6 +419,7 @@ export interface SystemUserRecord {
     systemRole: SystemRole;
     betaAccess: boolean;
     disabled: boolean;
+    internalFeatureGrants: InternalUserFeatureKey[];
     planId?: string | null;
     planName?: string | null;
     planVersionId?: string | null;
@@ -607,6 +616,7 @@ export interface McpAccessTokenRecord {
     userEmail?: string | null;
     name: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     tokenPrefix: string;
     status: McpAccessTokenStatus;
     lastUsedAt?: string | null;
@@ -634,6 +644,7 @@ export interface McpAccessTokenAuthResult {
     workspaceId: string;
     userId: string;
     scopes: McpAccessTokenScope[];
+    toolProfile?: McpCloudToolProfile;
     status: McpAccessTokenStatus;
 }
 export interface McpAccessTokenInspectionResult {
@@ -643,6 +654,7 @@ export interface McpAccessTokenInspectionResult {
     userId: string;
     name: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     status: McpAccessTokenStatus;
 }
 export interface McpOAuthClientRecord {
@@ -664,6 +676,7 @@ export interface McpOAuthConnectorGrantRecord {
     workspaceId: string;
     userId: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     tokenPrefix: string;
     status: McpOAuthGrantStatus;
     lastUsedAt?: string | null;
@@ -686,6 +699,7 @@ export interface McpOAuthAccessTokenAuthResult {
     provider: McpOAuthProvider;
     productClientId?: string | null;
     scopes: McpAccessTokenScope[];
+    toolProfile?: McpCloudToolProfile;
     status: McpOAuthGrantStatus;
     aiProfileId?: string | null;
     aiProfileToken?: string | null;

package/dist/documentReviews/commandService.d.ts

@@ -6,6 +6,7 @@ export interface ReviewDocumentCommandComment {
 export interface ReviewDocumentCommandInput {
     workspaceId: string;
     assetId: string;
+    documentVersion: number | null;
     documentLabel?: string | null;
     sessionId?: string | null;
     title?: string | null;
@@ -43,7 +44,7 @@ export declare class DocumentReviewCommandError extends Error {
 }
 export interface ReviewDocumentCommandResult {
     session: DocumentReviewSession;
-    sessionAction: 'reused' | 'created';
+    sessionAction: 'reused' | 'created' | 'created-for-current-version';
     postedCommentIds: string[];
 }
 export declare function createDocumentReviewCommandService(deps: DocumentReviewCommandServiceDependencies): {

package/dist/documentReviews/commandService.js

@@ -29,8 +29,9 @@ export function createDocumentReviewCommandService(deps) {
                     workspaceId: input.workspaceId,
                     assetId: input.assetId,
                 }).filter((candidate) => candidate.status === 'open');
-                if (openSessions.length === 1) {
-                    session = openSessions[0];
+                const currentVersionSessions = openSessions.filter((candidate) => candidate.documentVersion === input.documentVersion);
+                if (currentVersionSessions.length === 1) {
+                    session = currentVersionSessions[0];
                 }
                 else {
                     session = deps.createSession({
@@ -40,7 +41,9 @@ export function createDocumentReviewCommandService(deps) {
                         status: 'open',
                         actorId: input.actorId,
                     });
-                    sessionAction = 'created';
+                    sessionAction = currentVersionSessions.length === 0 && openSessions.length > 0
+                        ? 'created-for-current-version'
+                        : 'created';
                 }
             }
             const postedCommentIds = [];

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

@@ -28,6 +28,7 @@ export interface PersistedSyncWatermarks {
     taskRelationshipChangeKeys?: Map<string, string>;
     initiativeWatermarks: Map<string, string>;
     workstreamWatermarks: Map<string, string>;
+    planningIdentityWatermarks?: Map<string, string>;
     aiProfileWatermarks: Map<string, string>;
     aiProfileChangeKeys?: Map<string, string>;
     taskforceAgentWatermarks?: Map<string, string>;

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/useDurableLocalOutboxDrain.d.ts

@@ -6,7 +6,7 @@ export declare function useDurableLocalOutboxDrain(input: {
     workspaceId: string;
     mutationFingerprint: string;
     authorityScope: object;
-    remoteServices: Pick<WorkspaceSyncEngineRemoteServices, 'pullWorkspaceContent' | 'abandonTransferReceipts' | 'buildV2ApplyCompletionGroup'> | null;
+    remoteServices: Pick<WorkspaceSyncEngineRemoteServices, 'pullWorkspaceContent' | 'abandonTransferReceipts' | 'buildIndependentContentApplyCompletionGroup'> | null;
     localServices: Pick<WorkspaceSyncEngineLocalServices, 'applyV2Batch'>;
     isAuthorityCurrent?: (authorityScope: object) => boolean;
     onHydratedEventIds?: (eventIds: string[]) => void;

package/dist/hooks/sync/useDurableTaskCreateMutation.js

@@ -104,7 +104,7 @@ export function useDurableTaskCreateMutation(input) {
             clientRef.current = input.client || createLocalTaskCreateClient();
         const participant = await getParticipant(workspaceId);
         const selected = selectTaskCreateActivationInput(candidate);
-        const participantId = selected
+        const participantId = input.enabled && selected
             ? participant.prepareForDraft(await fingerprintTaskDraft(selected.localTask))
             : participant.participantId;
         let result;

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

@@ -2,6 +2,7 @@ import type { TaskItem } from '../../types.js';
 import { createLocalTaskMetadataClient, type LocalTaskMetadataMutationResult } from '../../sync/v3/localTaskMetadataClient.js';
 export type DurableTaskMetadataMutationAdapter = (taskId: string, patch: Partial<TaskItem>, options?: {
     saveSource?: 'manual' | 'autosave';
+    expectedDetailRevision?: string;
 }) => Promise<LocalTaskMetadataMutationResult | null>;
 type LocalTaskMetadataClient = ReturnType<typeof createLocalTaskMetadataClient>;
 export declare function useDurableTaskMetadataMutation(input: {

package/dist/hooks/sync/useDurableTaskMetadataMutation.js

@@ -17,6 +17,7 @@ export function useDurableTaskMetadataMutation(input) {
             entityId,
             patch: patch,
             ...(options?.saveSource ? { saveSource: options.saveSource } : {}),
+            ...(options?.expectedDetailRevision ? { expectedDetailRevision: options.expectedDetailRevision } : {}),
             isAuthenticated: input.isAuthenticated,
             dispatchEnabled: input.dispatchEnabled,
         });

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

@@ -6,6 +6,7 @@ export type DurableTaskStatusMutationAdapter = (taskId: string, payload: {
     assigneeIntent: DurableTaskStatusAssigneeIntent;
     canceledReason: string | null;
     metadataPatch?: Partial<TaskItem>;
+    expectedDetailRevision?: string;
 }) => Promise<LocalTaskStatusMutationResult | null>;
 type LocalTaskStatusClient = ReturnType<typeof createLocalTaskStatusClient>;
 export declare function useDurableTaskStatusMutation(input: {

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/tasks/taskHttpMutation.js

@@ -44,6 +44,7 @@ export async function isConclusiveTaskHttpResponse(response) {
         'TASK_ATTACHMENT_LINKS_INVALID',
         'TASK_COMMENT_INVALID',
         'TASK_COMMENT_IDENTITY_CONFLICT',
+        'TASK_DETAIL_REVISION_CONFLICT',
     ]).has(code);
 }
 function stableTaskCreateCandidate(candidate) {

package/dist/hooks/tasks/useCloudTaskSearch.d.ts

@@ -0,0 +1,12 @@
+interface UseCloudTaskSearchInput {
+    query: string;
+    runtimeMode: 'local' | 'cloud';
+    workspaceId: string;
+    enabled: boolean;
+    scope: 'active' | 'archive';
+    debounceMs?: number;
+    pageSize?: number;
+    maxMatches?: number;
+}
+export declare function useCloudTaskSearch({ query, runtimeMode, workspaceId, enabled, scope, debounceMs, pageSize, maxMatches, }: UseCloudTaskSearchInput): ReadonlySet<string>;
+export {};

package/dist/hooks/tasks/useCloudTaskSearch.js

@@ -0,0 +1,71 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { normalizeTaskSearchQuery } from '../../utils/taskSearch';
+export function useCloudTaskSearch({ query, runtimeMode, workspaceId, enabled, scope, debounceMs = 250, pageSize = 50, maxMatches = 500, }) {
+    const [matchIds, setMatchIds] = useState(() => new Set());
+    const requestSequenceRef = useRef(0);
+    const normalizedQuery = useMemo(() => normalizeTaskSearchQuery(query).raw, [query]);
+    useEffect(() => {
+        requestSequenceRef.current += 1;
+        const requestSequence = requestSequenceRef.current;
+        if (!enabled || runtimeMode !== 'cloud' || !normalizedQuery || !workspaceId.trim()) {
+            setMatchIds((current) => current.size === 0 ? current : new Set());
+            return;
+        }
+        setMatchIds((current) => current.size === 0 ? current : new Set());
+        const abortController = new AbortController();
+        const timer = window.setTimeout(() => {
+            void (async () => {
+                const collected = new Set();
+                let offset = 0;
+                let scanned = 0;
+                const boundedPageSize = Math.max(1, Math.min(50, Math.trunc(pageSize)));
+                const boundedMaxMatches = Math.max(1, Math.trunc(maxMatches));
+                try {
+                    while (scanned < boundedMaxMatches) {
+                        const limit = Math.min(boundedPageSize, boundedMaxMatches - scanned);
+                        const params = new URLSearchParams({
+                            query: query.trim(),
+                            scope,
+                            limit: String(limit),
+                            offset: String(offset),
+                        });
+                        const response = await fetch(`/api/taskforce/tasks/search?${params.toString()}`, {
+                            signal: abortController.signal,
+                        });
+                        if (!response.ok)
+                            throw new Error(`Task search failed (${response.status}).`);
+                        const body = await response.json();
+                        const matches = body.matches || [];
+                        scanned += matches.length;
+                        for (const match of matches) {
+                            const id = String(match?.id || '').trim();
+                            if (id)
+                                collected.add(id);
+                        }
+                        if (body.pagination?.hasMore !== true)
+                            break;
+                        const nextOffset = Number(body.pagination?.nextOffset);
+                        if (!Number.isInteger(nextOffset) || nextOffset <= offset)
+                            break;
+                        offset = nextOffset;
+                    }
+                    if (!abortController.signal.aborted && requestSequenceRef.current === requestSequence) {
+                        setMatchIds(collected);
+                    }
+                }
+                catch (error) {
+                    if (abortController.signal.aborted || requestSequenceRef.current !== requestSequence)
+                        return;
+                    // Server search augments the existing client matcher. On failure, retain
+                    // the client-visible metadata results instead of blocking the task board.
+                    setMatchIds(new Set());
+                }
+            })();
+        }, Math.max(0, debounceMs));
+        return () => {
+            window.clearTimeout(timer);
+            abortController.abort('superseded');
+        };
+    }, [debounceMs, enabled, maxMatches, normalizedQuery, pageSize, query, runtimeMode, scope, workspaceId]);
+    return matchIds;
+}

package/dist/hooks/tasks/useTaskDescriptionImageDraftRecovery.d.ts

@@ -0,0 +1,16 @@
+export type TaskDescriptionImageDraftResolution = 'promote' | 'discard';
+type DraftRecoveryFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface UseTaskDescriptionImageDraftRecoveryOptions {
+    fetchImpl?: DraftRecoveryFetch;
+    storage?: Storage | null;
+    now?: () => number;
+}
+export declare const TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY = "taskforce.task-description-image-draft-recovery.v1";
+export declare function taskDescriptionImageDraftRetryDelay(attempts: number): number;
+export declare function useTaskDescriptionImageDraftRecovery(workspaceId: string, createdByUserId: string, options?: UseTaskDescriptionImageDraftRecoveryOptions): {
+    resolveDraft: (input: {
+        draftUploadId: string;
+        resolution: TaskDescriptionImageDraftResolution;
+    }) => Promise<void>;
+};
+export {};