@taskforcehq/taskforce 0.3.305 → 0.3.306

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;

package/dist/utils/workspaceSyncPresentation.js

@@ -1,12 +1,78 @@
+function resolveBlockedReasonPresentation(reason) {
+    switch (reason) {
+        case 'auth-required':
+            return {
+                summary: 'Sync is paused until you sign in again.',
+                recommendedAction: 'Sign in, then press Sync to retry.'
+            };
+        case 'attach-cloud':
+            return {
+                summary: 'This workspace still needs its first cloud pull before local pushes can run.',
+                recommendedAction: 'Keep this window open for the first cloud pull. If it seems stuck, press Repair.'
+            };
+        case 'provision-local':
+            return {
+                summary: 'This workspace is still doing its first cloud upload before normal pulls can run.',
+                recommendedAction: 'Keep this window open until the first cloud upload finishes.'
+            };
+        case 'repair-active':
+            return {
+                summary: 'Repair is already running for this workspace.',
+                recommendedAction: 'Wait for repair to finish before retrying sync.'
+            };
+        case 'retry-pending':
+            return {
+                summary: 'Sync hit a temporary problem and is waiting for its scheduled retry.',
+                recommendedAction: 'Wait for the automatic retry, or press Sync to retry now.'
+            };
+        case 'push-in-flight':
+        case 'pull-in-flight':
+            return {
+                summary: 'A sync request is already running for this workspace.',
+                recommendedAction: 'Wait for the current sync request to finish.'
+            };
+        case 'lease-held':
+            return {
+                summary: 'Another local window is already syncing this workspace.',
+                recommendedAction: 'Use a single local window for sync, or close the other syncing window.'
+            };
+        case 'invalid-workspace':
+            return {
+                summary: 'Workspace setup is required before sync can run.',
+                recommendedAction: 'Open or create a named workspace before retrying sync.'
+            };
+        case 'cloud-auth-unconfigured':
+            return {
+                summary: 'Cloud sync is unavailable because cloud authentication is not configured.',
+                recommendedAction: 'Configure cloud authentication before turning on sync.'
+            };
+        case 'runtime-not-local':
+            return {
+                summary: 'Workspace sync controls are only available in the local runtime.',
+                recommendedAction: 'Open this workspace in the local app to manage sync.'
+            };
+        case 'sync-disabled':
+            return {
+                summary: 'Workspace sync is currently turned off.',
+                recommendedAction: 'Turn on sync when you are ready to connect this workspace to cloud.'
+            };
+        default:
+            return null;
+    }
+}
 export function resolveHeaderWorkspaceSyncPresentation(input) {
     const actionable = input.runtimeMode === 'local' && input.isAuthenticated;
     if (actionable) {
+        const blockedReasonPresentation = resolveBlockedReasonPresentation(input.retryBlockedReason
+            || input.pullBlockedReason
+            || input.pushBlockedReason
+            || null);
         return {
             actionable,
             status: input.workspaceSyncStatus,
             syncEnabledLabel: input.workspaceCloudSyncEnabled ? 'yes' : 'no',
-            summary: input.workspaceSyncSummary,
-            recommendedAction: input.workspaceSyncRecommendedAction,
+            summary: blockedReasonPresentation?.summary || input.workspaceSyncSummary,
+            recommendedAction: blockedReasonPresentation?.recommendedAction || input.workspaceSyncRecommendedAction,
             lastError: input.workspaceSyncError
         };
     }

package/dist/utils/workspaceSyncPresentation.test.js

@@ -25,7 +25,10 @@ describe('resolveHeaderWorkspaceSyncPresentation', () => {
             workspaceCloudSyncEnabled: true,
             workspaceSyncSummary: 'Sync needs attention before it can continue.',
             workspaceSyncRecommendedAction: 'Press Sync to retry.',
-            workspaceSyncError: 'Retry later'
+            workspaceSyncError: 'Retry later',
+            pushBlockedReason: null,
+            pullBlockedReason: null,
+            retryBlockedReason: null
         });
         expect(result.actionable).toBe(true);
         expect(result.status).toBe('attention');
@@ -33,4 +36,36 @@ describe('resolveHeaderWorkspaceSyncPresentation', () => {
         expect(result.summary).toBe('Sync needs attention before it can continue.');
         expect(result.lastError).toBe('Retry later');
     });
+    it('surfaces the highest-priority blocked sync reason in the visible summary', () => {
+        const result = resolveHeaderWorkspaceSyncPresentation({
+            runtimeMode: 'local',
+            isAuthenticated: true,
+            workspaceSyncStatus: 'attention',
+            workspaceCloudSyncEnabled: true,
+            workspaceSyncSummary: 'Sync needs attention before it can continue.',
+            workspaceSyncRecommendedAction: 'Press Sync to retry.',
+            workspaceSyncError: 'Retry later',
+            pushBlockedReason: 'attach-cloud',
+            pullBlockedReason: 'retry-pending',
+            retryBlockedReason: 'auth-required'
+        });
+        expect(result.summary).toBe('Sync is paused until you sign in again.');
+        expect(result.recommendedAction).toBe('Sign in, then press Sync to retry.');
+    });
+    it('explains when another local window holds the sync lease', () => {
+        const result = resolveHeaderWorkspaceSyncPresentation({
+            runtimeMode: 'local',
+            isAuthenticated: true,
+            workspaceSyncStatus: 'attention',
+            workspaceCloudSyncEnabled: true,
+            workspaceSyncSummary: 'Sync needs attention before it can continue.',
+            workspaceSyncRecommendedAction: 'Press Sync to retry.',
+            workspaceSyncError: 'Retry later',
+            pushBlockedReason: 'lease-held',
+            pullBlockedReason: null,
+            retryBlockedReason: null
+        });
+        expect(result.summary).toBe('Another local window is already syncing this workspace.');
+        expect(result.recommendedAction).toBe('Use a single local window for sync, or close the other syncing window.');
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taskforcehq/taskforce",
-  "version": "0.3.305",
+  "version": "0.3.306",
   "description": "Mission Command center for AI-powered task management (beta - under active development)",
   "author": "Taskforce HQ <hello@taskforcehq.ai> (https://taskforcehq.ai)",
   "license": "MIT",
@@ -54,7 +54,7 @@
     "build:ui": "npm run build:app",
     "check:deploy-preflight": "npm run build",
     "hooks:install": "git config core.hooksPath .githooks",
-    "build": "shx rm -rf dist && tsc && shx cp src/Taskforce.module.css dist/Taskforce.module.css && shx mkdir -p dist/resources && shx cp -r src/resources/* dist/resources/ && shx rm -f dist/resources/templates/workflows/release.yaml && shx mkdir -p dist/public && shx cp -r src/assets/images/* dist/public/ && shx cp -r src/assets/favicon/* dist/public/ && shx chmod +x dist/cli.js && npm run build:ui",
+    "build": "shx rm -rf dist && tsc && shx cp src/Taskforce.module.css dist/Taskforce.module.css && shx mkdir -p dist/styles && shx cp src/styles/fonts.css dist/styles/fonts.css && shx mkdir -p dist/assets/fonts && shx cp src/assets/fonts/*.woff2 dist/assets/fonts/ && shx mkdir -p dist/resources && shx cp -r src/resources/* dist/resources/ && shx rm -f dist/resources/templates/workflows/release.yaml && shx mkdir -p dist/public && shx cp -r src/assets/images/* dist/public/ && shx cp -r src/assets/favicon/* dist/public/ && shx chmod +x dist/cli.js && npm run build:ui",
     "mcp": "node dist/mcp/server.js",
     "gen:workflows": "node scripts/generate-workflow-templates.mjs",
     "check:workflows": "node scripts/generate-workflow-templates.mjs --check",
@@ -111,6 +111,7 @@
     "js-yaml": "^4.1.1",
     "nodemailer": "^6.10.1",
     "pg": "^8.18.0",
+    "react-avatar-editor": "^15.1.0",
     "rehype-sanitize": "^6.0.0",
     "stripe": "^20.3.1",
     "ws": "^8.18.0"