@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/utils/syncEventPresentation.js

@@ -50,10 +50,63 @@ function describeSyncPhase(phaseRaw) {
             return phase.length > 0 ? phase.replace(/-/g, ' ') : 'sync';
     }
 }
+function boundedOptionalNumber(value) {
+    if (value === null || value === undefined)
+        return null;
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.max(0, Math.floor(number)) : null;
+}
+function formatTransferProgress(processedRaw, knownTotalRaw, singularUnit) {
+    const processed = boundedOptionalNumber(processedRaw);
+    if (processed === null)
+        return null;
+    const knownTotal = boundedOptionalNumber(knownTotalRaw);
+    const unit = processed === 1 && (knownTotal === null || knownTotal === 1)
+        ? singularUnit
+        : `${singularUnit}s`;
+    return `${processed}${knownTotal === null ? '' : `/${knownTotal}`} ${unit}`;
+}
+function formatTransferBytes(bytesRaw, scopeRaw) {
+    const bytes = boundedOptionalNumber(bytesRaw);
+    if (bytes === null)
+        return null;
+    const formatted = bytes >= 1024 * 1024
+        ? `${(bytes / (1024 * 1024)).toFixed(1)} MiB`
+        : bytes >= 1024
+            ? `${(bytes / 1024).toFixed(1)} KiB`
+            : `${bytes} B`;
+    return String(scopeRaw || '') === 'content-bodies'
+        ? `${formatted} content`
+        : formatted;
+}
 function formatStructuredSyncEventLine(event) {
     const occurredAt = getOccurredAt(event);
     const details = normalizeSyncEventDetails(event.details);
     const source = getDetailsSource(event);
+    if (source === 'server-runner.transfer') {
+        const transfer = details?.transfer && typeof details.transfer === 'object'
+            ? details.transfer
+            : {};
+        const direction = String(transfer.direction || '').trim();
+        const operation = String(transfer.operation || event.eventType || 'sync').trim();
+        const outcome = String(transfer.outcome || event.status || '').trim() === 'error'
+            ? 'failed'
+            : 'succeeded';
+        const progress = [
+            formatTransferProgress(transfer.processedChanges, transfer.knownTotalChanges, 'change'),
+            formatTransferProgress(transfer.processedPages, transfer.knownTotalPages, 'page'),
+            formatTransferBytes(transfer.transferredBytes, transfer.transferredBytesScope),
+        ].filter((value) => Boolean(value));
+        const duration = boundedOptionalNumber(transfer.durationMs);
+        const errorMessage = outcome === 'failed'
+            && typeof event.errorMessage === 'string'
+            && event.errorMessage.trim()
+            ? `: ${event.errorMessage.trim()}`
+            : '';
+        return `${occurredAt} ${direction ? `${direction} ` : ''}${operation} ${outcome}`
+            + `${progress.length > 0 ? ` (${progress.join(', ')})` : ''}`
+            + `${duration === null ? '' : ` in ${duration}ms`}${errorMessage}`;
+    }
     if (source === 'retry.blocked') {
         return `${occurredAt} manual retry blocked: ${describeSyncReason(details?.reason)} during ${describeSyncPhase(details?.phase)}`;
     }

package/dist/utils/syncStatusPresentation.d.ts

@@ -40,6 +40,30 @@ export interface WorkspaceSyncDiagnosticsPresentation {
     documentSnapshotCount: number;
     assetSnapshotCount: number;
     forceFullAiProfilePushQueued?: boolean;
+    durableOutbox?: {
+        activeDepth: number;
+        pending: number;
+        inFlight: number;
+        blocked: number;
+        operationStates?: {
+            pending: number;
+            retryScheduled: number;
+            inFlight: number;
+            stale: number;
+            blocked: number;
+        };
+        oldestActiveCreatedAt: string | null;
+        blockedErrorCode: string | null;
+        recovery: {
+            state: 'awaiting_baseline' | 'baseline_ready' | 'replay_queued' | 'completed';
+            replayTotal: number;
+            replayPending: number;
+            replayInFlight: number;
+            replayBlocked: number;
+            replayAccepted: number;
+        } | null;
+    } | null;
+    coordinatorRecoveryObligations?: number;
 }
 interface BuildSyncEventRowsInput {
     syncRecentEvents: SyncEventRecord[];
@@ -62,6 +86,7 @@ interface BuildCopySyncDetailsTextInput {
     syncRecentEvents: SyncEventRecord[];
 }
 export declare function resolveSyncStatusMeta(status: HeaderWorkspaceSyncStatus): SyncStatusMeta;
+export declare function resolveHeaderSyncStatusMeta(status: HeaderWorkspaceSyncStatus, workspaceCloudSyncEnabled: boolean): SyncStatusMeta;
 export declare function resolveSyncStageLabel(workspaceSyncPhase: string, workspaceSyncRepairBusy: boolean, workspaceSyncBusy: boolean): string;
 export declare function buildSyncDiagnosticsSummary(workspaceSyncDiagnostics: WorkspaceSyncDiagnosticsPresentation): SyncSummaryItem[];
 export declare function buildSyncEventRows({ syncRecentEvents, syncRecentEventsError, syncRecentEventsLoading, }: BuildSyncEventRowsInput): SyncEventRow[];

package/dist/utils/syncStatusPresentation.js

@@ -1,4 +1,27 @@
 import { formatSyncEventLine, getSyncEventStableKey, } from './syncEventPresentation';
+import { stableStringifySyncEventDetails } from './syncEventDetails';
+function formatSyncEventForDisplay(event) {
+    const rawLine = formatSyncEventLine(event);
+    const occurredAt = String(event.occurredAt || '').trim();
+    if (!occurredAt || !rawLine.startsWith(occurredAt))
+        return rawLine;
+    const parsed = new Date(occurredAt);
+    if (Number.isNaN(parsed.getTime()))
+        return rawLine;
+    return `${parsed.toLocaleString()}${rawLine.slice(occurredAt.length)}`;
+}
+function getCollapsibleEventSignature(event) {
+    if (event.status === 'error')
+        return null;
+    return [
+        String(event.eventType || '').trim() || 'sync',
+        String(event.status || '').trim() || 'unknown-status',
+        String(event.statusCode ?? ''),
+        String(event.changeCount ?? ''),
+        String(event.errorMessage || '').trim(),
+        stableStringifySyncEventDetails(event.details),
+    ].join('|');
+}
 function formatDiagnosticsTimestamp(value) {
     if (!value)
         return 'Never';
@@ -43,6 +66,9 @@ export function resolveSyncStatusMeta(status) {
             };
     }
 }
+export function resolveHeaderSyncStatusMeta(status, workspaceCloudSyncEnabled) {
+    return resolveSyncStatusMeta(workspaceCloudSyncEnabled ? status : 'off');
+}
 export function resolveSyncStageLabel(workspaceSyncPhase, workspaceSyncRepairBusy, workspaceSyncBusy) {
     if (workspaceSyncRepairBusy) {
         return 'Repairing';
@@ -93,6 +119,32 @@ export function buildSyncDiagnosticsSummary(workspaceSyncDiagnostics) {
             label: 'Queued full AI sync',
             value: workspaceSyncDiagnostics.forceFullAiProfilePushQueued ? 'Yes' : 'No',
         },
+        {
+            label: 'Durable outbox',
+            value: workspaceSyncDiagnostics.durableOutbox
+                ? workspaceSyncDiagnostics.durableOutbox.operationStates
+                    ? `${workspaceSyncDiagnostics.durableOutbox.operationStates.pending} pending, `
+                        + `${workspaceSyncDiagnostics.durableOutbox.operationStates.retryScheduled} retry scheduled, `
+                        + `${workspaceSyncDiagnostics.durableOutbox.operationStates.inFlight} in flight, `
+                        + `${workspaceSyncDiagnostics.durableOutbox.operationStates.stale} stale, `
+                        + `${workspaceSyncDiagnostics.durableOutbox.operationStates.blocked} blocked`
+                    : `${workspaceSyncDiagnostics.durableOutbox.pending} pending, ${workspaceSyncDiagnostics.durableOutbox.inFlight} in flight, ${workspaceSyncDiagnostics.durableOutbox.blocked} blocked`
+                : 'Unavailable',
+        },
+        {
+            label: 'Durable recovery',
+            value: (() => {
+                const batch = workspaceSyncDiagnostics.durableOutbox?.recovery
+                    ? `${workspaceSyncDiagnostics.durableOutbox.recovery.state}; `
+                        + `${workspaceSyncDiagnostics.durableOutbox.recovery.replayAccepted}/${workspaceSyncDiagnostics.durableOutbox.recovery.replayTotal} replayed`
+                    : null;
+                const coordinatorObligations = workspaceSyncDiagnostics.coordinatorRecoveryObligations || 0;
+                const coordinator = coordinatorObligations > 0
+                    ? `${coordinatorObligations} coordinator obligations open`
+                    : null;
+                return [batch, coordinator].filter(Boolean).join(', ') || 'None';
+            })(),
+        },
         {
             label: 'AI snapshot last fetch',
             value: formatDiagnosticsTimestamp(workspaceSyncDiagnostics.aiProfileSnapshotLastFetchAt),
@@ -129,11 +181,26 @@ export function buildSyncEventRows({ syncRecentEvents, syncRecentEventsError, sy
                 tone: 'muted',
             }];
     }
-    return syncRecentEvents.map((event, index) => ({
-        key: getSyncEventStableKey(event, index),
-        text: formatSyncEventLine(event),
-        tone: event.status === 'error' ? 'error' : 'default',
-    }));
+    const rows = [];
+    for (const [index, event] of syncRecentEvents.entries()) {
+        const signature = getCollapsibleEventSignature(event);
+        const previous = rows[rows.length - 1];
+        if (signature && previous?.signature === signature) {
+            previous.repeatCount += 1;
+            previous.text = `${previous.baseText} × ${previous.repeatCount}`;
+            continue;
+        }
+        const baseText = formatSyncEventForDisplay(event);
+        rows.push({
+            key: getSyncEventStableKey(event, index),
+            text: baseText,
+            tone: event.status === 'error' ? 'error' : 'default',
+            signature,
+            repeatCount: 1,
+            baseText,
+        });
+    }
+    return rows.map(({ signature: _signature, repeatCount: _repeatCount, baseText: _baseText, ...row }) => row);
 }
 export function getActiveReferenceMismatchEvents(events) {
     const mismatches = [];
@@ -206,6 +273,20 @@ export function buildCopySyncDetailsText({ currentWorkspaceId, syncStatusLabel,
         `Asset snapshot: ${workspaceSyncDiagnostics.assetSnapshotCount}`,
         `Reference mismatches detected: ${referenceMismatchCount}`,
         `Queued full AI sync: ${workspaceSyncDiagnostics.forceFullAiProfilePushQueued ? 'Yes' : 'No'}`,
+        `Durable outbox pending: ${workspaceSyncDiagnostics.durableOutbox?.pending ?? 'Unavailable'}`,
+        `Durable outbox in flight: ${workspaceSyncDiagnostics.durableOutbox?.inFlight ?? 'Unavailable'}`,
+        `Durable outbox blocked: ${workspaceSyncDiagnostics.durableOutbox?.blocked ?? 'Unavailable'}`,
+        `Durable outbox retry scheduled: ${workspaceSyncDiagnostics.durableOutbox?.operationStates?.retryScheduled ?? 'Unavailable'}`,
+        `Durable outbox stale: ${workspaceSyncDiagnostics.durableOutbox?.operationStates?.stale ?? 'Unavailable'}`,
+        `Durable outbox oldest active: ${formatDiagnosticsTimestamp(workspaceSyncDiagnostics.durableOutbox?.oldestActiveCreatedAt)}`,
+        `Durable outbox blocked error code: ${workspaceSyncDiagnostics.durableOutbox?.blockedErrorCode || 'None'}`,
+        `Durable recovery state: ${workspaceSyncDiagnostics.durableOutbox?.recovery?.state || 'None'}`,
+        `Durable recovery replay total: ${workspaceSyncDiagnostics.durableOutbox?.recovery?.replayTotal ?? 0}`,
+        `Durable recovery replay pending: ${workspaceSyncDiagnostics.durableOutbox?.recovery?.replayPending ?? 0}`,
+        `Durable recovery replay in flight: ${workspaceSyncDiagnostics.durableOutbox?.recovery?.replayInFlight ?? 0}`,
+        `Durable recovery replay blocked: ${workspaceSyncDiagnostics.durableOutbox?.recovery?.replayBlocked ?? 0}`,
+        `Durable recovery replay accepted: ${workspaceSyncDiagnostics.durableOutbox?.recovery?.replayAccepted ?? 0}`,
+        `Durable recovery obligations (coordinator): ${workspaceSyncDiagnostics.coordinatorRecoveryObligations ?? 'Unavailable'}`,
     ];
     const recentEventLines = syncRecentEvents.map((event) => formatSyncEventLine(event));
     return [

package/dist/utils/taskActivity.d.ts

@@ -1,9 +1,15 @@
 import type { EntityActivityItem, EntityEvent, TaskActivityItem, TaskEvent, TaskItem } from '../types';
 export type TaskEventValueFormatter = (field: string, value: unknown) => string | undefined;
-export declare function summarizeTaskChange(field: string, change: {
+type AttachmentChange = {
     from?: unknown;
     to?: unknown;
-} | undefined, formatter?: TaskEventValueFormatter): string;
+    fromCount?: unknown;
+    toCount?: unknown;
+    added?: unknown;
+    removed?: unknown;
+    updated?: unknown;
+};
+export declare function summarizeTaskChange(field: string, change: AttachmentChange | undefined, formatter?: TaskEventValueFormatter): string;
 export declare function summarizeTaskEvent(event: TaskEvent, formatter?: TaskEventValueFormatter): string;
 export declare function summarizeEntityEvent(event: EntityEvent, formatter?: TaskEventValueFormatter): string;
 export declare function getTaskEventPrimaryChangeField(event: TaskEvent): string | null;
@@ -15,3 +21,4 @@ export declare function getEntityActivityItems(task: {
 export declare function getTaskActivityItems(task: Pick<TaskItem, 'activity' | 'comments'>): TaskActivityItem[];
 export declare function getLatestTaskActivity(task: Pick<TaskItem, 'activity' | 'comments'>): TaskActivityItem | null;
 export declare function summarizeTaskActivity(item: TaskActivityItem | null, formatter?: TaskEventValueFormatter): string;
+export {};

package/dist/utils/taskActivity.js

@@ -179,7 +179,63 @@ function capitalizeLeading(value) {
         return value;
     return value.charAt(0).toUpperCase() + value.slice(1);
 }
+function compactAttachmentLabels(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => typeof entry === 'string' ? entry.trim() : '').filter(Boolean);
+}
+function summarizeCompactAttachmentChange(change) {
+    if (Array.isArray(change.from) || Array.isArray(change.to))
+        return null;
+    const hasCompactShape = ['fromCount', 'toCount', 'added', 'removed', 'updated']
+        .some((key) => Object.prototype.hasOwnProperty.call(change, key));
+    if (!hasCompactShape)
+        return null;
+    const added = compactAttachmentLabels(change.added);
+    const removed = compactAttachmentLabels(change.removed);
+    const updated = compactAttachmentLabels(change.updated);
+    if (added.length === 1 && removed.length === 0 && updated.length === 0) {
+        return `Attachment attached: ${added[0]}`;
+    }
+    if (removed.length === 1 && added.length === 0 && updated.length === 0) {
+        return `Attachment removed: ${removed[0]}`;
+    }
+    if (added.length === 1 && removed.length === 1 && updated.length === 0) {
+        return `Attachment replaced: ${removed[0]} -> ${added[0]}`;
+    }
+    if (updated.length === 1 && added.length === 0 && removed.length === 0) {
+        return `Attachment updated: ${updated[0]}`;
+    }
+    if (updated.length > 0 && added.length === 0 && removed.length === 0) {
+        return `${updated.length} attachments updated`;
+    }
+    if (added.length > 0 || removed.length > 0) {
+        const parts = [
+            ...(added.length > 0 ? [`${added.length} ${added.length === 1 ? 'attachment' : 'attachments'} attached`] : []),
+            ...(removed.length > 0 ? [`${removed.length} ${removed.length === 1 ? 'attachment' : 'attachments'} removed`] : []),
+            ...(updated.length > 0 ? [`${updated.length} ${updated.length === 1 ? 'attachment' : 'attachments'} updated`] : []),
+        ];
+        return capitalizeLeading(parts.join(', '));
+    }
+    const fromCount = Number(change.fromCount);
+    const toCount = Number(change.toCount);
+    if (Number.isSafeInteger(fromCount) && fromCount >= 0 && Number.isSafeInteger(toCount) && toCount >= 0) {
+        const delta = toCount - fromCount;
+        if (delta === 1)
+            return 'Attachment attached';
+        if (delta > 1)
+            return `${delta} attachments attached`;
+        if (delta === -1)
+            return 'Attachment removed';
+        if (delta < -1)
+            return `${Math.abs(delta)} attachments removed`;
+    }
+    return 'Attachment details updated';
+}
 function summarizeAttachmentChange(change) {
+    const compactSummary = change ? summarizeCompactAttachmentChange(change) : null;
+    if (compactSummary)
+        return compactSummary;
     const before = normalizeAttachmentList(change?.from);
     const after = normalizeAttachmentList(change?.to);
     const beforeByKey = new Map(before.map((entry) => [entry.key, entry]));
@@ -367,6 +423,11 @@ export function getEntityActivityItems(task) {
     const addItem = (item) => {
         if (item.type === 'event' && item.event.action === 'task-comment-added')
             return;
+        if (item.type === 'event'
+            && item.event.action === 'task-updated'
+            && item.event.details?.saveSource === 'autosave'
+            && Object.keys(item.event.details?.changes || {}).length === 0)
+            return;
         const key = item.type === 'comment'
             ? `comment:${String(item.comment.id || item.id).replace(/^comment:/, '')}`
             : `event:${String(item.event.id || item.id).replace(/^event:/, '')}`;

package/dist/utils/taskDraftDefaults.d.ts

@@ -1,21 +1,13 @@
 import type { CategoryConfig, TaskAssignee, TaskStatus } from '../types';
-type ApproachOption = {
-    value: string;
-    label: string;
-};
 export interface DraftDefaultsForGrouping {
     category?: string;
     type?: string;
     priority?: number;
     complexity?: number;
-    approach?: string;
-    taxonomyApproach?: string;
     assignee?: TaskAssignee;
     status?: TaskStatus;
     scheduledDate?: string;
 }
 export declare function resolveDraftDefaultsForGrouping(groupField: string, value: string | number, options: {
     categories: CategoryConfig[];
-    approaches: ApproachOption[];
 }): DraftDefaultsForGrouping;
-export {};

package/dist/utils/taskDraftDefaults.js

@@ -13,10 +13,6 @@ export function resolveDraftDefaultsForGrouping(groupField, value, options) {
     if (groupField === 'complexity') {
         return Number.isFinite(Number(value)) ? { complexity: Number(value) } : {};
     }
-    if (groupField === 'approach') {
-        const match = options.approaches.find((approach) => String(approach.value) === normalizedValue || approach.label === normalizedValue);
-        return match ? { approach: match.value, taxonomyApproach: match.value } : {};
-    }
     if (groupField === 'assignee') {
         if (normalizedValue.trim().length > 0) {
             return { assignee: normalizedValue };

package/dist/utils/taskEvents.d.ts

@@ -0,0 +1,11 @@
+import type { TaskItem } from '../types.js';
+import type { TaskCollection } from './taskInvalidation.js';
+export declare const TASKFORCE_TASKS_MUTATED_EVENT = "taskforce:tasks-mutated";
+export interface TaskforceTasksMutatedDetail {
+    workspaceId?: string | null;
+    taskId?: string | null;
+    reason?: 'agent-comment' | 'agent-checklist' | 'workflow-step';
+    authoritativeTask?: TaskItem | null;
+    affectedCollections?: TaskCollection[];
+}
+export declare function dispatchTaskforceTasksMutated(detail: TaskforceTasksMutatedDetail): void;

package/dist/utils/taskEvents.js

@@ -0,0 +1,6 @@
+export const TASKFORCE_TASKS_MUTATED_EVENT = 'taskforce:tasks-mutated';
+export function dispatchTaskforceTasksMutated(detail) {
+    if (typeof window === 'undefined' || typeof window.dispatchEvent !== 'function')
+        return;
+    window.dispatchEvent(new CustomEvent(TASKFORCE_TASKS_MUTATED_EVENT, { detail }));
+}

package/dist/utils/taskHeaderQuickFilter.d.ts

@@ -0,0 +1,14 @@
+import type { TaskItem } from '../types';
+export type TaskHeaderQuickFilter = 'assigned-to-me' | 'overdue';
+interface UseTaskHeaderQuickFilterInput {
+    authUserId: string;
+    taskScope: 'open' | 'archived' | 'deleted';
+    workspaceId: string;
+}
+export declare function useTaskHeaderQuickFilter({ authUserId, taskScope, workspaceId, }: UseTaskHeaderQuickFilterInput): {
+    taskHeaderQuickFilter: TaskHeaderQuickFilter | null;
+    toggleTaskHeaderQuickFilter: (filter: TaskHeaderQuickFilter) => void;
+    clearTaskHeaderQuickFilter: () => void;
+};
+export declare function matchesTaskHeaderQuickFilter(task: TaskItem, filter: TaskHeaderQuickFilter, authUserId: string, todayDateOnly: string): boolean;
+export {};

package/dist/utils/taskHeaderQuickFilter.js

@@ -0,0 +1,32 @@
+import { useCallback, useEffect, useState } from 'react';
+export function useTaskHeaderQuickFilter({ authUserId, taskScope, workspaceId, }) {
+    const [taskHeaderQuickFilter, setTaskHeaderQuickFilter] = useState(null);
+    useEffect(() => {
+        setTaskHeaderQuickFilter(null);
+    }, [authUserId, workspaceId]);
+    useEffect(() => {
+        if (taskScope !== 'open')
+            setTaskHeaderQuickFilter(null);
+    }, [taskScope]);
+    const toggleTaskHeaderQuickFilter = useCallback((filter) => {
+        setTaskHeaderQuickFilter((current) => current === filter ? null : filter);
+    }, []);
+    const clearTaskHeaderQuickFilter = useCallback(() => {
+        setTaskHeaderQuickFilter(null);
+    }, []);
+    return {
+        taskHeaderQuickFilter,
+        toggleTaskHeaderQuickFilter,
+        clearTaskHeaderQuickFilter,
+    };
+}
+export function matchesTaskHeaderQuickFilter(task, filter, authUserId, todayDateOnly) {
+    if (task.status === 'done' || task.status === 'cancelled')
+        return false;
+    if (String(task.assignee || '').trim() !== authUserId)
+        return false;
+    if (filter === 'overdue') {
+        return Boolean(task.dueDate && task.dueDate < todayDateOnly);
+    }
+    return true;
+}

package/dist/utils/taskInvalidation.d.ts

@@ -0,0 +1,23 @@
+export type TaskCollection = 'active' | 'archive' | 'deleted' | 'planning';
+export interface TaskInvalidationScope {
+    collections: TaskCollection[];
+    taskIds?: string[];
+    ambiguous?: boolean;
+}
+export interface TaskInvalidationMetadata {
+    entityType?: string;
+    changeType?: string;
+    entityIds?: string[];
+    affectedCollections?: string[];
+}
+export declare function createTaskInvalidationScope(collections: readonly TaskCollection[], options?: {
+    taskIds?: readonly string[];
+    ambiguous?: boolean;
+}): TaskInvalidationScope;
+export declare function mergeTaskInvalidationScopes(current: TaskInvalidationScope | null, next: TaskInvalidationScope): TaskInvalidationScope;
+/**
+ * Ambiguous refreshes reconcile state without implying that every changed task
+ * should draw attention. Targeted invalidations retain their explicit IDs.
+ */
+export declare function resolveTaskInvalidationHighlightIds(scope: TaskInvalidationScope): string[];
+export declare function resolveRealtimeTaskInvalidation(signalType: string, invalidations: readonly TaskInvalidationMetadata[] | undefined): TaskInvalidationScope;

package/dist/utils/taskInvalidation.js

@@ -0,0 +1,67 @@
+const ALL_COLLECTIONS = ['active', 'archive', 'deleted', 'planning'];
+function normalizeCollections(values) {
+    const selected = new Set(values || []);
+    return ALL_COLLECTIONS.filter((value) => selected.has(value));
+}
+function normalizeIds(values) {
+    return Array.from(new Set((values || []).map((value) => String(value || '').trim()).filter(Boolean)));
+}
+export function createTaskInvalidationScope(collections, options) {
+    return {
+        collections: normalizeCollections(collections),
+        taskIds: normalizeIds(options?.taskIds),
+        ambiguous: options?.ambiguous === true,
+    };
+}
+export function mergeTaskInvalidationScopes(current, next) {
+    if (!current) {
+        return createTaskInvalidationScope(next.collections, {
+            taskIds: next.taskIds,
+            ambiguous: next.ambiguous,
+        });
+    }
+    return createTaskInvalidationScope([...current.collections, ...next.collections], {
+        taskIds: [...(current.taskIds || []), ...(next.taskIds || [])],
+        ambiguous: current.ambiguous || next.ambiguous,
+    });
+}
+/**
+ * Ambiguous refreshes reconcile state without implying that every changed task
+ * should draw attention. Targeted invalidations retain their explicit IDs.
+ */
+export function resolveTaskInvalidationHighlightIds(scope) {
+    return scope.ambiguous ? [] : [...(scope.taskIds || [])];
+}
+export function resolveRealtimeTaskInvalidation(signalType, invalidations) {
+    if (signalType === 'taskforce:update'
+        || signalType === 'taskforce:replay-gap'
+        || signalType === 'taskforce:replay-reset'
+        || !invalidations?.length) {
+        return createTaskInvalidationScope(ALL_COLLECTIONS, { ambiguous: true });
+    }
+    let scope = null;
+    for (const invalidation of invalidations) {
+        const entityType = String(invalidation.entityType || '').trim();
+        const explicitCollections = normalizeCollections(invalidation.affectedCollections);
+        let collections;
+        if (explicitCollections.length > 0) {
+            collections = explicitCollections;
+        }
+        else if (entityType === 'task') {
+            collections = String(invalidation.changeType || '').trim() === 'delete'
+                ? ['active', 'archive', 'deleted']
+                : ['active', 'archive', 'deleted', 'planning'];
+        }
+        else if (entityType === 'taxonomy') {
+            collections = ['active', 'archive', 'planning'];
+        }
+        else if (entityType === 'initiative' || entityType === 'workstream') {
+            collections = ['planning'];
+        }
+        else {
+            collections = [];
+        }
+        scope = mergeTaskInvalidationScopes(scope, createTaskInvalidationScope(collections, { taskIds: invalidation.entityIds }));
+    }
+    return scope || createTaskInvalidationScope([]);
+}

package/dist/utils/taskNormalization.d.ts

@@ -12,8 +12,9 @@ export declare function normalizePriorityDefinitions(priorities: PriorityDefinit
     priorities: NormalizedPriorityDefinition[];
     changed: boolean;
 };
-export declare function getPriorityClass(priority: string | number, fallbackLabel: string): string;
 export declare function normalizeTaskFromApi(task: any): TaskItem;
+export declare function getTaskContentRevision(task: TaskItem): string;
+export declare function reconcileTaskCollection(previous: TaskItem[], incoming: TaskItem[]): TaskItem[];
 export declare function mergeNormalizedTaskIntoCollections(task: unknown, tasks: TaskItem[], archivedTasks: TaskItem[]): {
     tasks: TaskItem[];
     archivedTasks: TaskItem[];

package/dist/utils/taskNormalization.js

@@ -8,13 +8,6 @@ const PRIORITY_VALUE_BY_LABEL = {
     critical: 4,
     'on-hold': 1,
 };
-const PRIORITY_CLASS_MAP = {
-    '1': 'low',
-    '2': 'medium',
-    '3': 'high',
-    '4': 'critical',
-    '5': 'critical',
-};
 function normalizeTaskStatus(status) {
     const normalized = String(status || '').trim().toLowerCase();
     if (normalized === 'blocked' || normalized === 'on hold' || normalized === 'on-hold')
@@ -66,9 +59,6 @@ export function normalizePriorityDefinitions(priorities) {
         changed
     };
 }
-export function getPriorityClass(priority, fallbackLabel) {
-    return PRIORITY_CLASS_MAP[String(priority)] || fallbackLabel;
-}
 export function normalizeTaskFromApi(task) {
     const referenceNumber = typeof task.referenceNumber === 'number'
         ? task.referenceNumber
@@ -106,6 +96,27 @@ export function normalizeTaskFromApi(task) {
         status: normalizeTaskStatus(task.status)
     };
 }
+export function getTaskContentRevision(task) {
+    // Use the complete normalized snapshot: some task changes can arrive without a
+    // distinct updatedAt value, so a timestamp-only key could retain stale UI data.
+    return JSON.stringify(task);
+}
+export function reconcileTaskCollection(previous, incoming) {
+    if (previous.length === 0)
+        return incoming.length === 0 ? previous : incoming;
+    const previousById = new Map(previous.map((task) => [task.id, task]));
+    let collectionChanged = previous.length !== incoming.length;
+    const reconciled = incoming.map((task, index) => {
+        const existing = previousById.get(task.id);
+        const nextTask = existing && getTaskContentRevision(existing) === getTaskContentRevision(task)
+            ? existing
+            : task;
+        if (nextTask !== previous[index])
+            collectionChanged = true;
+        return nextTask;
+    });
+    return collectionChanged ? reconciled : previous;
+}
 export function mergeNormalizedTaskIntoCollections(task, tasks, archivedTasks) {
     if (!task || typeof task !== 'object') {
         return { tasks, archivedTasks };
@@ -119,6 +130,15 @@ export function mergeNormalizedTaskIntoCollections(task, tasks, archivedTasks) {
     const nextTask = shouldArchive
         ? { ...normalizedTask, isArchived: true }
         : { ...normalizedTask, isArchived: false };
+    const existingTargetTask = (shouldArchive ? archivedTasks : tasks)
+        .find((item) => item.id === taskId);
+    const existsInOtherCollection = (shouldArchive ? tasks : archivedTasks)
+        .some((item) => item.id === taskId);
+    if (existingTargetTask
+        && !existsInOtherCollection
+        && getTaskContentRevision(existingTargetTask) === getTaskContentRevision(nextTask)) {
+        return { tasks, archivedTasks };
+    }
     const sortCollection = (items) => {
         return [...items].sort((a, b) => {
             const aTimestamp = Date.parse(String(a.updatedAt || a.createdAt || ''));
@@ -135,18 +155,24 @@ export function mergeNormalizedTaskIntoCollections(task, tasks, archivedTasks) {
             return String(a.id).localeCompare(String(b.id));
         });
     };
-    const nextTasks = tasks.filter((item) => item.id !== taskId);
-    const nextArchivedTasks = archivedTasks.filter((item) => item.id !== taskId);
+    const nextTasks = tasks.some((item) => item.id === taskId)
+        ? tasks.filter((item) => item.id !== taskId)
+        : tasks;
+    const nextArchivedTasks = archivedTasks.some((item) => item.id === taskId)
+        ? archivedTasks.filter((item) => item.id !== taskId)
+        : archivedTasks;
     if (shouldArchive) {
-        nextArchivedTasks.push(nextTask);
+        return {
+            tasks: nextTasks,
+            archivedTasks: sortCollection([...nextArchivedTasks, nextTask])
+        };
     }
     else {
-        nextTasks.push(nextTask);
+        return {
+            tasks: sortCollection([...nextTasks, nextTask]),
+            archivedTasks: nextArchivedTasks
+        };
     }
-    return {
-        tasks: sortCollection(nextTasks),
-        archivedTasks: sortCollection(nextArchivedTasks)
-    };
 }
 export function normalizePriorityFilterValues(filterPriorities, priorities) {
     if (!priorities.length || !filterPriorities.length)