@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/utils/syncStatusPresentation.test.js

@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+import { buildCopySyncDetailsText, buildReferenceMismatchSummaries, buildSyncDiagnosticsSummary, buildSyncEventRows, getActiveReferenceMismatchCount, resolveSyncStageLabel, resolveSyncStatusMeta, } from './syncStatusPresentation';
+describe('syncStatusPresentation', () => {
+    it('resolves sync status badges for visible header states', () => {
+        expect(resolveSyncStatusMeta('healthy')).toMatchObject({
+            label: 'Healthy',
+            icon: 'cloud',
+        });
+        expect(resolveSyncStatusMeta('attention')).toMatchObject({
+            label: 'Needs Attention',
+            icon: 'cloud',
+        });
+        expect(resolveSyncStatusMeta('off')).toMatchObject({
+            label: 'Off',
+            icon: 'off',
+        });
+    });
+    it('describes startup and repair stages for the sync manager', () => {
+        expect(resolveSyncStageLabel('attach-cloud', false, true)).toBe('Initial cloud pull');
+        expect(resolveSyncStageLabel('error', true, true)).toBe('Repairing');
+        expect(resolveSyncStageLabel('error', false, true)).toBe('Recovering');
+    });
+    it('builds the diagnostics summary from sync snapshot counts', () => {
+        const summary = buildSyncDiagnosticsSummary({
+            aiProfileSnapshotCount: 2,
+            aiProfileSnapshotRawCount: 4,
+            lastPushedAiProfileCount: 3,
+            lastPushedAiProfileWatermarkCount: 5,
+            documentSnapshotCount: 1,
+            assetSnapshotCount: 2,
+            forceFullAiProfilePushQueued: true,
+            aiProfileSnapshotLastFetchAt: null,
+            aiProfileSnapshotLastFetchError: '',
+            aiProfileSnapshotLastSkipReason: null,
+        });
+        expect(summary).toContainEqual({
+            label: 'AI profile snapshot',
+            value: '2 local profiles',
+        });
+        expect(summary).toContainEqual({
+            label: 'Document snapshot',
+            value: '1 local doc',
+        });
+        expect(summary).toContainEqual({
+            label: 'Queued full AI sync',
+            value: 'Yes',
+        });
+    });
+    it('keeps only active reference mismatches until the next successful sync event', () => {
+        const events = [
+            {
+                occurredAt: '2026-04-18T10:00:00.000Z',
+                status: 'error',
+                errorMessage: 'Detected task reference number mismatch during normal sync.',
+                details: {
+                    path: 'docs/spec.md',
+                    existingReferenceNumber: 14,
+                    incomingReferenceNumber: 8,
+                },
+            },
+            {
+                occurredAt: '2026-04-18T09:59:00.000Z',
+                status: 'success',
+                errorMessage: '',
+            },
+            {
+                occurredAt: '2026-04-18T09:58:00.000Z',
+                status: 'error',
+                errorMessage: 'Detected task reference number mismatch during normal sync.',
+            },
+        ];
+        expect(getActiveReferenceMismatchCount(events)).toBe(1);
+        expect(buildReferenceMismatchSummaries(events)).toEqual([
+            expect.objectContaining({
+                pathLabel: 'docs/spec.md',
+                refsLabel: 'Existing 14 vs incoming 8',
+            }),
+        ]);
+    });
+    it('builds readable sync event rows for loading, errors, and structured events', () => {
+        expect(buildSyncEventRows({
+            syncRecentEvents: [],
+            syncRecentEventsError: null,
+            syncRecentEventsLoading: true,
+        })).toEqual([{
+                key: 'loading',
+                text: 'Loading recent sync events...',
+                tone: 'muted',
+            }]);
+        expect(buildSyncEventRows({
+            syncRecentEvents: [],
+            syncRecentEventsError: 'Unable to load events.',
+            syncRecentEventsLoading: false,
+        })).toEqual([{
+                key: 'error',
+                text: 'Unable to load events.',
+                tone: 'error',
+            }]);
+        expect(buildSyncEventRows({
+            syncRecentEvents: [{
+                    occurredAt: '2026-04-18T10:00:00.000Z',
+                    status: 'error',
+                    details: {
+                        source: 'retry.blocked',
+                        reason: 'lease-held',
+                        phase: 'active',
+                    },
+                }],
+            syncRecentEventsError: null,
+            syncRecentEventsLoading: false,
+        })[0]).toMatchObject({
+            tone: 'error',
+            text: '2026-04-18T10:00:00.000Z manual retry blocked: another window is already syncing during active sync',
+        });
+    });
+    it('assembles the sync manager report text from the current view model', () => {
+        const report = buildCopySyncDetailsText({
+            currentWorkspaceId: 'workspace-123',
+            syncStatusLabel: 'Needs Attention',
+            workspaceSyncSummary: 'Sync is paused until you sign in again.',
+            workspaceSyncRecommendedAction: 'Sign in, then press Sync to retry.',
+            formattedLastSyncTime: '4/17/2026, 10:32:47 PM',
+            formattedLastPullTime: '4/17/2026, 10:32:47 PM',
+            formattedLastPushTime: '4/17/2026, 10:31:45 PM',
+            workspaceSyncDiagnostics: {
+                lastErrorAt: '2026-04-18T01:33:05.980Z',
+                pushBlockedReason: 'attach-cloud',
+                pullBlockedReason: null,
+                retryBlockedReason: 'auth-required',
+                repairActive: false,
+                pushInFlight: false,
+                pullInFlight: true,
+                retryPending: false,
+                aiProfileSnapshotCount: 14,
+                aiProfileSnapshotRawCount: 14,
+                lastPushedAiProfileCount: 14,
+                lastPushedAiProfileWatermarkCount: 14,
+                aiProfileSnapshotLastFetchAt: '2026-04-18T11:15:52.000Z',
+                aiProfileSnapshotLastFetchError: null,
+                aiProfileSnapshotLastSkipReason: null,
+                documentSnapshotCount: 127,
+                assetSnapshotCount: 56,
+                forceFullAiProfilePushQueued: false,
+            },
+            workspaceSyncPendingChanges: 31,
+            syncLastError: 'Detected task reference number mismatch during normal sync.',
+            syncStageLabel: 'Active',
+            referenceMismatchCount: 3,
+            syncRecentEvents: [{
+                    occurredAt: '2026-04-18T01:33:06.044Z',
+                    eventType: 'apply',
+                    status: 'success',
+                    changeCount: 200,
+                    requestMs: 167,
+                    statusCode: 0,
+                }],
+        });
+        expect(report).toContain('Workspace ID: workspace-123');
+        expect(report).toContain('Push blocked reason: attach-cloud');
+        expect(report).toContain('Retry blocked reason: auth-required');
+        expect(report).toContain('Reference mismatches detected: 3');
+        expect(report).toContain('2026-04-18T01:33:06.044Z apply succeeded (200 changes) in 167ms [0]');
+    });
+});

package/dist/utils/taskActivity.d.ts

@@ -5,5 +5,7 @@ export declare function summarizeTaskChange(field: string, change: {
     to?: unknown;
 } | undefined, formatter?: TaskEventValueFormatter): string;
 export declare function summarizeTaskEvent(event: TaskEvent, formatter?: TaskEventValueFormatter): string;
+export declare function getTaskEventPrimaryChangeField(event: TaskEvent): string | null;
+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;

package/dist/utils/taskActivity.js

@@ -1,16 +1,31 @@
 function getActivityFieldLabel(field) {
     if (field === 'title')
-        return 'TITLE';
+        return 'Title';
     if (field === 'description')
-        return 'DESCRIPTION';
+        return 'Description';
     if (field === 'assignee')
-        return 'ASSIGNED TO';
+        return 'Assigned to';
+    if (field === 'status')
+        return 'Status';
+    if (field === 'scheduledDate')
+        return 'Scheduled date';
+    if (field === 'dueDate')
+        return 'Due date';
     if (field === 'workstreamId')
-        return 'WORKSTREAM';
+        return 'Workstream';
     if (field === 'initiativeId')
-        return 'INITIATIVE';
+        return 'Initiative';
     return field;
 }
+function formatStatusValue(value) {
+    if (value === 'task')
+        return 'Task';
+    return value
+        .replace(/[-_]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
 function formatValue(value, field, formatter) {
     const formatted = formatter?.(field, value);
     if (typeof formatted === 'string')
@@ -23,6 +38,8 @@ function formatValue(value, field, formatter) {
     }
     if (typeof value === 'object')
         return 'updated';
+    if (field === 'status')
+        return formatStatusValue(String(value));
     return String(value);
 }
 function normalizeChecklistItems(value) {
@@ -75,10 +92,131 @@ function summarizeChecklistChange(change) {
     }
     return 'Checklist updated';
 }
+function stripQueryAndHash(value) {
+    return value.split(/[?#]/, 1)[0] || value;
+}
+function basenameFromPath(value) {
+    const normalized = stripQueryAndHash(value).replace(/\\/g, '/');
+    const segments = normalized.split('/').filter(Boolean);
+    return segments[segments.length - 1] || normalized;
+}
+function isImageAttachmentCandidate(value) {
+    return /\.(png|jpe?g|webp|gif)$/i.test(stripQueryAndHash(value));
+}
+function isDocumentAttachmentCandidate(value) {
+    if (value.includes('/api/taskforce/documents/'))
+        return true;
+    return /\.(pdf|txt|md|markdown|csv|json|docx?|html?|js|jsx|ts|tsx|css|py|java|go|rs|sh)$/i.test(stripQueryAndHash(value));
+}
+function normalizeAttachmentList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry, index) => {
+        const attachment = (entry && typeof entry === 'object' ? entry : null);
+        const path = typeof entry === 'string'
+            ? entry
+            : String(attachment?.path || '').trim();
+        const fsPath = String(attachment?.fsPath || '').trim();
+        const assetId = String(attachment?.assetId || '').trim();
+        const referenceLabel = String(attachment?.referenceLabel || '').trim();
+        const label = [
+            attachment?.displayName,
+            attachment?.originalFilename,
+            attachment?.caption,
+            referenceLabel,
+            fsPath ? basenameFromPath(fsPath) : '',
+            path ? basenameFromPath(path) : '',
+        ]
+            .map((candidate) => String(candidate || '').trim())
+            .find(Boolean) || `Attachment ${index + 1}`;
+        const key = assetId || fsPath || path || `${label}:${index}`;
+        const kindCandidates = [
+            path,
+            fsPath,
+            String(attachment?.originalFilename || '').trim(),
+            String(attachment?.displayName || '').trim(),
+            referenceLabel,
+        ].filter(Boolean);
+        const kind = kindCandidates.some((candidate) => isImageAttachmentCandidate(candidate))
+            ? 'image'
+            : (referenceLabel.startsWith('D-') || kindCandidates.some((candidate) => isDocumentAttachmentCandidate(candidate)))
+                ? 'document'
+                : 'attachment';
+        return [{ key, label, kind }];
+    });
+}
+function pluralizeAttachmentKind(kind, count) {
+    if (count === 1)
+        return kind;
+    if (kind === 'image')
+        return 'images';
+    if (kind === 'document')
+        return 'documents';
+    return 'attachments';
+}
+function describeAttachmentCollection(entries) {
+    if (entries.length === 0)
+        return 'attachments';
+    const counts = entries.reduce((acc, entry) => {
+        acc[entry.kind] += 1;
+        return acc;
+    }, { image: 0, document: 0, attachment: 0 });
+    const nonZeroParts = Object.entries(counts)
+        .filter(([, count]) => count > 0)
+        .map(([kind, count]) => count === 1 ? kind : `${count} ${pluralizeAttachmentKind(kind, count)}`);
+    if (nonZeroParts.length === 1)
+        return nonZeroParts[0];
+    if (entries.length <= 3 && nonZeroParts.length <= 2)
+        return nonZeroParts.join(' and ');
+    return `${entries.length} attachments`;
+}
+function capitalizeLeading(value) {
+    if (!value)
+        return value;
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function summarizeAttachmentChange(change) {
+    const before = normalizeAttachmentList(change?.from);
+    const after = normalizeAttachmentList(change?.to);
+    const beforeByKey = new Map(before.map((entry) => [entry.key, entry]));
+    const afterByKey = new Map(after.map((entry) => [entry.key, entry]));
+    const added = after.filter((entry) => !beforeByKey.has(entry.key));
+    const removed = before.filter((entry) => !afterByKey.has(entry.key));
+    if (added.length === 1 && removed.length === 0) {
+        return `${capitalizeLeading(added[0].kind)} attached: ${added[0].label}`;
+    }
+    if (removed.length === 1 && added.length === 0) {
+        return `${capitalizeLeading(removed[0].kind)} removed: ${removed[0].label}`;
+    }
+    if (added.length > 0 && removed.length === 0) {
+        return `${capitalizeLeading(describeAttachmentCollection(added))} attached`;
+    }
+    if (removed.length > 0 && added.length === 0) {
+        return `${capitalizeLeading(describeAttachmentCollection(removed))} removed`;
+    }
+    if (added.length === 1 && removed.length === 1) {
+        return `${capitalizeLeading(added[0].kind)} replaced: ${removed[0].label} -> ${added[0].label}`;
+    }
+    if (added.length > 0 || removed.length > 0) {
+        return `${capitalizeLeading(describeAttachmentCollection(added))} attached, ${describeAttachmentCollection(removed)} removed`;
+    }
+    const relabeled = after.filter((entry) => {
+        const previous = beforeByKey.get(entry.key);
+        return previous && previous.label !== entry.label;
+    });
+    if (relabeled.length === 1 && before.length === 1 && after.length === 1) {
+        const previous = beforeByKey.get(relabeled[0].key);
+        return `${capitalizeLeading(relabeled[0].kind)} renamed: ${previous?.label || 'Attachment'} -> ${relabeled[0].label}`;
+    }
+    return 'Attachment details updated';
+}
 export function summarizeTaskChange(field, change, formatter) {
     if (field === 'checklistItems') {
         return summarizeChecklistChange(change);
     }
+    if (field === 'attachments') {
+        return summarizeAttachmentChange(change);
+    }
     const label = getActivityFieldLabel(field);
     if (field === 'title') {
         return `${label}: updated`;
@@ -108,22 +246,28 @@ export function summarizeTaskEvent(event, formatter) {
     if (event.action === 'task-unarchived')
         return 'Task restored';
     if (event.action === 'task-status-changed' && changes.status) {
-        return `Status: ${formatValue(changes.status.from, 'status', formatter)} -> ${formatValue(changes.status.to, 'status', formatter)}`;
+        return `Status changed: ${formatValue(changes.status.from, 'status', formatter)} -> ${formatValue(changes.status.to, 'status', formatter)}`;
     }
     if (event.action === 'task-schedule-changed') {
         if (changes.scheduledDate) {
-            return `Scheduled: ${formatValue(changes.scheduledDate.from, 'scheduledDate', formatter)} -> ${formatValue(changes.scheduledDate.to, 'scheduledDate', formatter)}`;
+            return `Scheduled date changed: ${formatValue(changes.scheduledDate.from, 'scheduledDate', formatter)} -> ${formatValue(changes.scheduledDate.to, 'scheduledDate', formatter)}`;
         }
         if (changes.dueDate) {
-            return `Due: ${formatValue(changes.dueDate.from, 'dueDate', formatter)} -> ${formatValue(changes.dueDate.to, 'dueDate', formatter)}`;
+            return `Due date changed: ${formatValue(changes.dueDate.from, 'dueDate', formatter)} -> ${formatValue(changes.dueDate.to, 'dueDate', formatter)}`;
         }
         return 'Schedule updated';
     }
     if (event.action === 'task-relationship-changed' && changes.workstreamId) {
-        return `Workstream: ${formatValue(changes.workstreamId.from, 'workstreamId', formatter)} -> ${formatValue(changes.workstreamId.to, 'workstreamId', formatter)}`;
+        return `Workstream changed: ${formatValue(changes.workstreamId.from, 'workstreamId', formatter)} -> ${formatValue(changes.workstreamId.to, 'workstreamId', formatter)}`;
+    }
+    if (event.action === 'task-relationship-changed' && changes.initiativeId) {
+        return `Initiative changed: ${formatValue(changes.initiativeId.from, 'initiativeId', formatter)} -> ${formatValue(changes.initiativeId.to, 'initiativeId', formatter)}`;
+    }
+    if (event.action === 'task-attachments-changed') {
+        return changes.attachments
+            ? summarizeTaskChange('attachments', changes.attachments, formatter)
+            : 'Attachments updated';
     }
-    if (event.action === 'task-attachments-changed')
-        return 'Attachments updated';
     if (fields.length === 1) {
         const field = fields[0];
         const change = changes[field];
@@ -133,25 +277,87 @@ export function summarizeTaskEvent(event, formatter) {
         return `${fields.length} fields updated`;
     return 'Task updated';
 }
-export function getLatestTaskActivity(task) {
-    const items = Array.isArray(task.activity) && task.activity.length > 0
-        ? task.activity
-        : Array.isArray(task.comments)
-            ? task.comments.map((comment) => ({
-                id: `comment:${comment.id}`,
+function activityTimestamp(item) {
+    const parsed = Date.parse(String(item.timestamp || ''));
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function getTaskEventPrimaryChangeField(event) {
+    const changes = event.details?.changes || {};
+    const fields = Object.keys(changes);
+    if (event.action === 'task-status-changed' && changes.status)
+        return 'status';
+    if (event.action === 'task-schedule-changed') {
+        if (changes.scheduledDate)
+            return 'scheduledDate';
+        if (changes.dueDate)
+            return 'dueDate';
+    }
+    if (event.action === 'task-relationship-changed') {
+        if (changes.workstreamId)
+            return 'workstreamId';
+        if (changes.initiativeId)
+            return 'initiativeId';
+    }
+    if (event.action === 'task-attachments-changed' && changes.attachments)
+        return 'attachments';
+    return fields.length === 1 ? fields[0] : null;
+}
+export function getTaskActivityItems(task) {
+    const deduped = new Map();
+    const commentIds = new Set();
+    const addItem = (item) => {
+        if (item.type === 'event' && item.event.action === 'task-comment-added')
+            return;
+        const key = item.type === 'comment'
+            ? `comment:${String(item.comment.id || item.id).replace(/^comment:/, '')}`
+            : `event:${String(item.event.id || item.id).replace(/^event:/, '')}`;
+        deduped.set(key, { ...item, id: key });
+        if (item.type === 'comment') {
+            commentIds.add(String(item.comment.id || item.id).replace(/^comment:/, ''));
+        }
+    };
+    if (Array.isArray(task.activity)) {
+        task.activity.forEach(addItem);
+    }
+    if (Array.isArray(task.comments)) {
+        task.comments.forEach((comment) => {
+            const commentId = String(comment.id || '').trim();
+            if (!commentId || commentIds.has(commentId))
+                return;
+            addItem({
+                id: `comment:${commentId}`,
                 type: 'comment',
                 timestamp: comment.timestamp,
                 comment
-            }))
-            : [];
+            });
+        });
+    }
+    return [...deduped.values()].sort((left, right) => {
+        const leftTs = activityTimestamp(left);
+        const rightTs = activityTimestamp(right);
+        if (leftTs !== null && rightTs !== null && leftTs !== rightTs)
+            return leftTs - rightTs;
+        if (leftTs !== null && rightTs === null)
+            return -1;
+        if (leftTs === null && rightTs !== null)
+            return 1;
+        return String(left.id || '').localeCompare(String(right.id || ''));
+    });
+}
+export function getLatestTaskActivity(task) {
+    const items = getTaskActivityItems(task);
     if (items.length === 0)
         return null;
     return [...items].sort((left, right) => {
-        const leftTs = Date.parse(String(left.timestamp || ''));
-        const rightTs = Date.parse(String(right.timestamp || ''));
-        if (Number.isFinite(leftTs) && Number.isFinite(rightTs) && leftTs !== rightTs) {
+        const leftTs = activityTimestamp(left);
+        const rightTs = activityTimestamp(right);
+        if (leftTs !== null && rightTs !== null && leftTs !== rightTs) {
             return rightTs - leftTs;
         }
+        if (leftTs !== null && rightTs === null)
+            return -1;
+        if (leftTs === null && rightTs !== null)
+            return 1;
         return String(right.id || '').localeCompare(String(left.id || ''));
     })[0] || null;
 }

package/dist/utils/taskActivity.test.js

@@ -1,32 +1,32 @@
 import { describe, expect, it } from 'vitest';
-import { summarizeTaskChange, summarizeTaskEvent } from './taskActivity';
+import { getTaskActivityItems, summarizeTaskChange, summarizeTaskEvent } from './taskActivity';
 describe('summarizeTaskChange', () => {
     it('summarizes title edits without dumping before and after text', () => {
         expect(summarizeTaskChange('title', {
             from: 'Old title',
             to: 'New title',
-        })).toBe('TITLE: updated');
+        })).toBe('Title: updated');
     });
-    it('summarizes assignee changes with uppercase labels and formatted values', () => {
+    it('summarizes assignee changes with sentence-case labels and formatted values', () => {
         expect(summarizeTaskChange('assignee', { from: 'unassigned', to: 'member-1' }, (_field, value) => {
             if (value === 'unassigned')
                 return 'Unassigned';
             if (value === 'member-1')
                 return 'Emma Peel';
             return undefined;
-        })).toBe('ASSIGNED TO: Unassigned -> Emma Peel');
+        })).toBe('Assigned to: Unassigned -> Emma Peel');
     });
     it('summarizes description additions without rendering the body text', () => {
         expect(summarizeTaskChange('description', {
             from: '',
             to: 'Line one\n\nLine two',
-        })).toBe('DESCRIPTION: added');
+        })).toBe('Description: added');
     });
     it('summarizes description clears without rendering the old body text', () => {
         expect(summarizeTaskChange('description', {
             from: 'Old body',
             to: '',
-        })).toBe('DESCRIPTION: cleared');
+        })).toBe('Description: cleared');
     });
     it('summarizes checklist completion clearly', () => {
         expect(summarizeTaskChange('checklistItems', {
@@ -59,7 +59,49 @@ describe('summarizeTaskChange', () => {
         })).toBe('Checklist reordered');
     });
     it('uses readable labels for workstream relationship changes', () => {
-        expect(summarizeTaskChange('workstreamId', { from: null, to: 'workstream-1' }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('WORKSTREAM: none -> WS-12');
+        expect(summarizeTaskChange('workstreamId', { from: null, to: 'workstream-1' }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('Workstream: none -> WS-12');
+    });
+    it('summarizes image attachment additions clearly', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [],
+            to: [{
+                    path: '/api/taskforce/context/workspaces/default/assets/images/homepage-proof.png',
+                    caption: 'Homepage proof',
+                }],
+        })).toBe('Image attached: Homepage proof');
+    });
+    it('summarizes document attachment removals clearly', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [{
+                    path: '/api/taskforce/documents/asset-doc-1/content',
+                    originalFilename: 'spec.md',
+                    assetId: 'asset-doc-1',
+                }],
+            to: [],
+        })).toBe('Document removed: spec.md');
+    });
+    it('summarizes multiple document attachments concisely', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [],
+            to: [
+                { path: '/api/taskforce/documents/asset-doc-1/content', originalFilename: 'spec.md', assetId: 'asset-doc-1' },
+                { path: '/api/taskforce/documents/asset-doc-2/content', originalFilename: 'notes.pdf', assetId: 'asset-doc-2' },
+            ],
+        })).toBe('2 documents attached');
+    });
+    it('summarizes attachment renames when the same asset remains attached', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [{
+                    path: '/api/taskforce/documents/asset-doc-1/content',
+                    assetId: 'asset-doc-1',
+                    caption: 'Draft spec',
+                }],
+            to: [{
+                    path: '/api/taskforce/documents/asset-doc-1/content',
+                    assetId: 'asset-doc-1',
+                    caption: 'Final spec',
+                }],
+        })).toBe('Document renamed: Draft spec -> Final spec');
     });
 });
 describe('summarizeTaskEvent', () => {
@@ -80,6 +122,75 @@ describe('summarizeTaskEvent', () => {
                     },
                 },
             },
-        }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('Workstream: none -> WS-12');
+        }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('Workstream changed: none -> WS-12');
+    });
+    it('uses attachment-specific summaries for attachment activity events', () => {
+        expect(summarizeTaskEvent({
+            id: 'event-2',
+            taskId: 'task-1',
+            workspaceId: 'default',
+            action: 'task-attachments-changed',
+            actor: 'user',
+            actorType: 'human',
+            createdAt: '2026-04-12T21:42:00.000Z',
+            details: {
+                changes: {
+                    attachments: {
+                        from: [{
+                                path: '/api/taskforce/context/workspaces/default/assets/images/old-proof.png',
+                                caption: 'Old proof',
+                            }],
+                        to: [{
+                                path: '/api/taskforce/context/workspaces/default/assets/images/new-proof.png',
+                                caption: 'New proof',
+                            }],
+                    },
+                },
+            },
+        })).toBe('Image replaced: Old proof -> New proof');
+    });
+});
+describe('getTaskActivityItems', () => {
+    it('combines comments and audit events while hiding duplicate comment-added events', () => {
+        const items = getTaskActivityItems({
+            comments: [{
+                    id: 'comment-1',
+                    author: 'user',
+                    text: 'Captured comment',
+                    timestamp: '2026-03-22T10:00:00.000Z',
+                }],
+            activity: [
+                {
+                    id: 'event:event-1',
+                    type: 'event',
+                    timestamp: '2026-03-22T09:00:00.000Z',
+                    event: {
+                        id: 'event-1',
+                        taskId: 'task-1',
+                        workspaceId: 'default',
+                        action: 'task-status-changed',
+                        actor: 'user',
+                        actorType: 'human',
+                        createdAt: '2026-03-22T09:00:00.000Z',
+                        details: { changes: { status: { from: 'task', to: 'in-progress' } } },
+                    },
+                },
+                {
+                    id: 'event:comment-event-1',
+                    type: 'event',
+                    timestamp: '2026-03-22T10:00:00.000Z',
+                    event: {
+                        id: 'comment-event-1',
+                        taskId: 'task-1',
+                        workspaceId: 'default',
+                        action: 'task-comment-added',
+                        actor: 'user',
+                        actorType: 'human',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                    },
+                },
+            ],
+        });
+        expect(items.map((item) => item.id)).toEqual(['event:event-1', 'comment:comment-1']);
     });
 });

package/dist/utils/workspaceSyncPresentation.d.ts

@@ -1,4 +1,5 @@
 export type HeaderWorkspaceSyncStatus = 'off' | 'syncing' | 'attention' | 'healthy';
+type WorkspaceSyncBlockedReason = 'cloud-auth-unconfigured' | 'runtime-not-local' | 'sync-disabled' | 'invalid-workspace' | 'repair-active' | 'attach-cloud' | 'provision-local' | 'auth-required' | 'push-in-flight' | 'pull-in-flight' | 'retry-pending' | 'lease-held';
 interface ResolveHeaderWorkspaceSyncPresentationInput {
     runtimeMode: 'local' | 'cloud';
     isAuthenticated: boolean;
@@ -7,6 +8,9 @@ interface ResolveHeaderWorkspaceSyncPresentationInput {
     workspaceSyncSummary: string;
     workspaceSyncRecommendedAction: string;
     workspaceSyncError: string;
+    pushBlockedReason?: WorkspaceSyncBlockedReason | null;
+    pullBlockedReason?: WorkspaceSyncBlockedReason | null;
+    retryBlockedReason?: WorkspaceSyncBlockedReason | null;
 }
 export interface HeaderWorkspaceSyncPresentation {
     actionable: boolean;