@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/core/types.d.ts

@@ -104,7 +104,7 @@ export interface ScheduleBoardResult {
         }>;
     };
 }
-export type RealtimeMutationEntityType = 'task' | 'taxonomy' | 'document-metadata';
+export type RealtimeMutationEntityType = 'task' | 'initiative' | 'workstream' | 'taxonomy' | 'document-metadata';
 export interface RealtimeMutationEvent {
     eventId: string;
     workspaceId: string;
@@ -141,6 +141,7 @@ export interface TaskforceConfig {
     storagePath?: string;
     tenantId?: string;
     runtimeMode?: RuntimeMode;
+    initializationMode?: 'standard' | 'cloud-read-worker';
     database?: {
         provider?: DatabaseProvider;
         connectionString?: string;
@@ -175,6 +176,12 @@ export interface TaskFile {
         jsonBackupEnabled?: boolean;
         manualComplexityEnabled?: boolean;
         checklistDropdownEnabled?: boolean;
+        showTaskCardStatusLabel?: boolean;
+        showTaskCardDescription?: boolean;
+        showTaskCardAttachments?: boolean;
+        showTaskCardChecklistProgress?: boolean;
+        showTaskCardLatestActivity?: boolean;
+        tintTaskCardActivityBackground?: boolean;
         taxonomies?: any[];
     };
 }

package/dist/documentReviews/DocumentReviewCommentStore.d.ts

@@ -28,7 +28,18 @@ export declare class DocumentReviewCommentStore {
         threadStatusUpdatedAt?: string | null;
         resolvedAt?: string | null;
         resolvedByActorId?: string | null;
+        idempotencyKey?: string | null;
+        idempotencyFingerprint?: string | null;
+        idempotencyActorScope?: string | null;
     }): DocumentReviewCommentSyncRecord;
+    getByIdempotencyKey(input: {
+        workspaceId: string;
+        actorScope: string;
+        idempotencyKey: string;
+    }): {
+        comment: DocumentReviewCommentSyncRecord;
+        fingerprint: string;
+    } | null;
     get(commentIdRaw: string, workspaceIdRaw: string, options?: {
         includeDeleted?: boolean;
     }): DocumentReviewCommentSyncRecord | null;

package/dist/documentReviews/DocumentReviewCommentStore.js

@@ -149,16 +149,49 @@ export class DocumentReviewCommentStore {
                 thread_status_updated_at,
                 resolved_at,
                 resolved_by_actor_id,
+                idempotency_key,
+                idempotency_fingerprint,
+                idempotency_actor_scope,
                 order_index,
                 created_at,
                 updated_at,
                 deleted_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ${normalizeNullable(input.idempotencyKey)
+            ? 'ON CONFLICT (tenant_id, workspace_id, idempotency_actor_scope, idempotency_key) DO NOTHING'
+            : ''}
         `).run(id, sessionId, this.tenantId, workspaceId, normalizeId(input.body), input.anchor ? JSON.stringify(input.anchor) : null, normalizeNullable(input.authorActorId), normalizeNullable(input.updatedByActorId ?? input.authorActorId), normalizeNullable(input.deletedByActorId), parentCommentId, parentCommentId
             ? null
-            : (input.threadStatus === 'resolved' ? 'resolved' : 'open'), parentCommentId ? null : (normalizeNullable(input.threadStatusUpdatedAt) || updatedAt), parentCommentId ? null : normalizeNullable(input.resolvedAt), parentCommentId ? null : normalizeNullable(input.resolvedByActorId), normalizePositiveInteger(input.order) ?? 0, createdAt, updatedAt, normalizeNullable(input.deletedAt));
+            : (input.threadStatus === 'resolved' ? 'resolved' : 'open'), parentCommentId ? null : (normalizeNullable(input.threadStatusUpdatedAt) || updatedAt), parentCommentId ? null : normalizeNullable(input.resolvedAt), parentCommentId ? null : normalizeNullable(input.resolvedByActorId), normalizeNullable(input.idempotencyKey), normalizeNullable(input.idempotencyFingerprint), normalizeId(input.idempotencyActorScope), normalizePositiveInteger(input.order) ?? 0, createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        if (normalizeNullable(input.idempotencyKey)) {
+            const replay = this.getByIdempotencyKey({
+                workspaceId,
+                actorScope: normalizeId(input.idempotencyActorScope),
+                idempotencyKey: normalizeId(input.idempotencyKey),
+            });
+            if (replay)
+                return replay.comment;
+        }
         return this.get(id, workspaceId, { includeDeleted: true });
     }
+    getByIdempotencyKey(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const row = this.db.prepare(`
+            SELECT *
+            FROM document_review_comments
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND idempotency_actor_scope = ?
+              AND idempotency_key = ?
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, normalizeId(input.actorScope), normalizeId(input.idempotencyKey));
+        if (!row)
+            return null;
+        return {
+            comment: mapRow(row),
+            fingerprint: normalizeId(row.idempotency_fingerprint),
+        };
+    }
     get(commentIdRaw, workspaceIdRaw, options) {
         const commentId = normalizeId(commentIdRaw);
         const workspaceId = normalizeWorkspaceId(workspaceIdRaw);

package/dist/documentReviews/service.d.ts

@@ -49,6 +49,8 @@ export declare function addDocumentReviewCommentService(deps: DocumentReviewServ
     body: string;
     anchor?: DocumentReviewAnchor | null;
     actorId?: string | null;
+    idempotencyKey?: string | null;
+    commentId?: string | null;
 }): DocumentReviewSession;
 export declare function addDocumentReviewReplyService(deps: DocumentReviewServiceDeps, input: {
     workspaceId?: string | null;
@@ -56,6 +58,8 @@ export declare function addDocumentReviewReplyService(deps: DocumentReviewServic
     parentCommentId: string;
     body: string;
     actorId?: string | null;
+    idempotencyKey?: string | null;
+    commentId?: string | null;
 }): DocumentReviewSession;
 export declare function updateDocumentReviewThreadStatusService(deps: DocumentReviewServiceDeps, input: {
     workspaceId?: string | null;

package/dist/documentReviews/service.js

@@ -1,9 +1,50 @@
+import { createHash } from 'node:crypto';
 function normalizeId(value) {
     return String(value || '').trim();
 }
 function normalizeCommentBody(value) {
     return String(value || '').trim();
 }
+function normalizeIdempotencyKey(value) {
+    if (value === undefined || value === null)
+        return null;
+    const key = String(value).trim();
+    if (!key || key.length > 128)
+        return null;
+    return key;
+}
+function documentReviewCommentFingerprint(input) {
+    return createHash('sha256').update(JSON.stringify(input)).digest('hex');
+}
+function resolveDocumentReviewCommentReplay(deps, input) {
+    if (!input.idempotencyKey)
+        return null;
+    const existing = deps.commentStore.getByIdempotencyKey({
+        workspaceId: input.workspaceId,
+        actorScope: input.actorScope,
+        idempotencyKey: input.idempotencyKey,
+    });
+    const synchronizedCommentId = normalizeId(input.commentId);
+    const synchronizedComment = !existing && synchronizedCommentId
+        ? deps.commentStore.get(synchronizedCommentId, input.workspaceId, { includeDeleted: true })
+        : null;
+    const replayComment = existing?.comment || synchronizedComment;
+    const replayFingerprint = existing?.fingerprint || (synchronizedComment
+        ? documentReviewCommentFingerprint({
+            sessionId: synchronizedComment.sessionId,
+            parentCommentId: synchronizedComment.parentCommentId,
+            body: normalizeCommentBody(synchronizedComment.body),
+            anchor: normalizeAnchorInput(synchronizedComment.anchor),
+            actorScope: normalizeId(synchronizedComment.authorActorId) || 'anonymous',
+        })
+        : null);
+    if (!replayComment)
+        return null;
+    if (replayFingerprint !== input.fingerprint || replayComment.deletedAt) {
+        throw deps.createRuleError('idempotencyKey is already assigned to a different document review comment.', 409, 'DOCUMENT_REVIEW_IDEMPOTENCY_CONFLICT');
+    }
+    return replayComment;
+}
 function normalizeStatus(value) {
     return String(value || '').trim().toLowerCase() === 'resolved' ? 'resolved' : 'open';
 }
@@ -194,46 +235,74 @@ export function updateDocumentReviewSessionService(deps, input) {
 }
 export function addDocumentReviewCommentService(deps, input) {
     const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
-    const existing = deps.sessionStore.get(input.sessionId, workspaceId);
-    if (!existing)
-        throw deps.createRuleError('Document review session not found.', 404, 'DOCUMENT_REVIEW_SESSION_NOT_FOUND');
-    getRequiredDocumentAsset(deps, workspaceId, existing.assetId);
-    if (existing.status === 'resolved') {
-        throw deps.createRuleError('Reopen this review before adding comments.', 409, 'DOCUMENT_REVIEW_RESOLVED');
-    }
-    const body = normalizeCommentBody(input.body);
-    if (!body)
-        throw deps.createRuleError('Comment body is required.', 400, 'DOCUMENT_REVIEW_COMMENT_REQUIRED');
-    const anchorError = validateDocumentReviewAnchorInput(input.anchor);
-    if (anchorError)
-        throw deps.createRuleError(anchorError, 400, 'DOCUMENT_REVIEW_ANCHOR_INVALID');
-    const now = new Date().toISOString();
-    deps.commentStore.create({
-        id: deps.generateEntityId('document-review-comment'),
-        sessionId: existing.id,
-        workspaceId,
-        order: nextCommentOrder(deps.commentStore.listForSession(existing.id, workspaceId, { includeDeleted: true })),
-        body,
-        anchor: normalizeAnchorInput(input.anchor),
-        authorActorId: normalizeId(input.actorId) || null,
-        updatedByActorId: normalizeId(input.actorId) || null,
-        deletedByActorId: null,
-        parentCommentId: null,
-        threadStatus: 'open',
-        threadStatusUpdatedAt: now,
-        resolvedAt: null,
-        resolvedByActorId: null,
-        createdAt: now,
-        updatedAt: now,
-        deletedAt: null,
-    });
-    const updated = deps.sessionStore.update({
-        id: existing.id,
-        workspaceId,
-        updatedByActorId: normalizeId(input.actorId) || null,
-        updatedAt: now,
+    return inTransaction(deps, () => {
+        const existing = deps.sessionStore.get(input.sessionId, workspaceId);
+        if (!existing)
+            throw deps.createRuleError('Document review session not found.', 404, 'DOCUMENT_REVIEW_SESSION_NOT_FOUND');
+        getRequiredDocumentAsset(deps, workspaceId, existing.assetId);
+        const body = normalizeCommentBody(input.body);
+        if (!body)
+            throw deps.createRuleError('Comment body is required.', 400, 'DOCUMENT_REVIEW_COMMENT_REQUIRED');
+        const anchorError = validateDocumentReviewAnchorInput(input.anchor);
+        if (anchorError)
+            throw deps.createRuleError(anchorError, 400, 'DOCUMENT_REVIEW_ANCHOR_INVALID');
+        const anchor = normalizeAnchorInput(input.anchor);
+        const actorScope = normalizeId(input.actorId) || 'anonymous';
+        const idempotencyKey = normalizeIdempotencyKey(input.idempotencyKey);
+        const commentId = normalizeId(input.commentId) || null;
+        if (input.idempotencyKey != null && !idempotencyKey) {
+            throw deps.createRuleError('idempotencyKey must contain 1 to 128 characters.', 400, 'DOCUMENT_REVIEW_IDEMPOTENCY_KEY_INVALID');
+        }
+        const fingerprint = documentReviewCommentFingerprint({
+            sessionId: existing.id, parentCommentId: null, body, anchor, actorScope,
+        });
+        const replay = resolveDocumentReviewCommentReplay(deps, {
+            workspaceId, idempotencyKey, commentId, actorScope, fingerprint,
+        });
+        if (replay)
+            return hydrateSession(deps, existing);
+        if (existing.status === 'resolved') {
+            throw deps.createRuleError('Reopen this review before adding comments.', 409, 'DOCUMENT_REVIEW_RESOLVED');
+        }
+        const now = new Date().toISOString();
+        const createdCommentId = commentId || deps.generateEntityId('document-review-comment');
+        const created = deps.commentStore.create({
+            id: createdCommentId,
+            sessionId: existing.id,
+            workspaceId,
+            order: nextCommentOrder(deps.commentStore.listForSession(existing.id, workspaceId, { includeDeleted: true })),
+            body,
+            anchor,
+            authorActorId: normalizeId(input.actorId) || null,
+            updatedByActorId: normalizeId(input.actorId) || null,
+            deletedByActorId: null,
+            parentCommentId: null,
+            threadStatus: 'open',
+            threadStatusUpdatedAt: now,
+            resolvedAt: null,
+            resolvedByActorId: null,
+            createdAt: now,
+            updatedAt: now,
+            deletedAt: null,
+            idempotencyKey,
+            idempotencyFingerprint: idempotencyKey ? fingerprint : null,
+            idempotencyActorScope: idempotencyKey ? actorScope : '',
+        });
+        if (created.id !== createdCommentId) {
+            const concurrentReplay = resolveDocumentReviewCommentReplay(deps, {
+                workspaceId, idempotencyKey, commentId: createdCommentId, actorScope, fingerprint,
+            });
+            if (concurrentReplay)
+                return hydrateSession(deps, existing);
+        }
+        const updated = deps.sessionStore.update({
+            id: existing.id,
+            workspaceId,
+            updatedByActorId: normalizeId(input.actorId) || null,
+            updatedAt: now,
+        });
+        return hydrateSession(deps, updated);
     });
-    return hydrateSession(deps, updated);
 }
 export function addDocumentReviewReplyService(deps, input) {
     const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
@@ -242,24 +311,40 @@ export function addDocumentReviewReplyService(deps, input) {
         if (!session)
             throw deps.createRuleError('Document review session not found.', 404, 'DOCUMENT_REVIEW_SESSION_NOT_FOUND');
         getRequiredDocumentAsset(deps, workspaceId, session.assetId);
+        const body = normalizeCommentBody(input.body);
+        if (!body)
+            throw deps.createRuleError('Reply body is required.', 400, 'DOCUMENT_REVIEW_COMMENT_REQUIRED');
+        const actorId = normalizeId(input.actorId) || null;
+        const actorScope = actorId || 'anonymous';
+        const parentCommentId = normalizeId(input.parentCommentId);
+        const idempotencyKey = normalizeIdempotencyKey(input.idempotencyKey);
+        const commentId = normalizeId(input.commentId) || null;
+        if (input.idempotencyKey != null && !idempotencyKey) {
+            throw deps.createRuleError('idempotencyKey must contain 1 to 128 characters.', 400, 'DOCUMENT_REVIEW_IDEMPOTENCY_KEY_INVALID');
+        }
+        const fingerprint = documentReviewCommentFingerprint({
+            sessionId: session.id, parentCommentId, body, anchor: null, actorScope,
+        });
+        const replay = resolveDocumentReviewCommentReplay(deps, {
+            workspaceId, idempotencyKey, commentId, actorScope, fingerprint,
+        });
+        if (replay)
+            return hydrateSession(deps, session);
         if (session.status === 'resolved') {
             throw deps.createRuleError('Reopen this review before replying.', 409, 'DOCUMENT_REVIEW_RESOLVED');
         }
         const comments = deps.commentStore.listForSession(session.id, workspaceId, { includeDeleted: true });
-        const root = comments.find((comment) => comment.id === normalizeId(input.parentCommentId) && !comment.deletedAt);
+        const root = comments.find((comment) => comment.id === parentCommentId && !comment.deletedAt);
         if (!root || root.parentCommentId) {
             throw deps.createRuleError('Document review thread not found.', 404, 'DOCUMENT_REVIEW_THREAD_NOT_FOUND');
         }
         if (root.threadStatus === 'resolved') {
             throw deps.createRuleError('Reopen this thread before replying.', 409, 'DOCUMENT_REVIEW_THREAD_RESOLVED');
         }
-        const body = normalizeCommentBody(input.body);
-        if (!body)
-            throw deps.createRuleError('Reply body is required.', 400, 'DOCUMENT_REVIEW_COMMENT_REQUIRED');
-        const actorId = normalizeId(input.actorId) || null;
         const now = new Date().toISOString();
-        deps.commentStore.create({
-            id: deps.generateEntityId('document-review-comment'),
+        const createdCommentId = commentId || deps.generateEntityId('document-review-comment');
+        const created = deps.commentStore.create({
+            id: createdCommentId,
             sessionId: session.id,
             workspaceId,
             parentCommentId: root.id,
@@ -276,7 +361,17 @@ export function addDocumentReviewReplyService(deps, input) {
             createdAt: now,
             updatedAt: now,
             deletedAt: null,
+            idempotencyKey,
+            idempotencyFingerprint: idempotencyKey ? fingerprint : null,
+            idempotencyActorScope: idempotencyKey ? actorScope : '',
         });
+        if (created.id !== createdCommentId) {
+            const concurrentReplay = resolveDocumentReviewCommentReplay(deps, {
+                workspaceId, idempotencyKey, commentId: createdCommentId, actorScope, fingerprint,
+            });
+            if (concurrentReplay)
+                return hydrateSession(deps, session);
+        }
         const updated = deps.sessionStore.update({
             id: session.id,
             workspaceId,

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/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 {};