@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/sync/workspaceSyncModel.test.js

@@ -48,6 +48,397 @@ describe('workspaceSyncModel', () => {
                 ['docs/new.md', '2026-02-03T00:00:00.000Z']
             ]);
         });
+        it('preserves canonical document metadata on document-upsert changes', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                documents: [
+                    {
+                        path: 'workspaces/default/assets/documents/asset-doc-1-notes.md',
+                        updatedAt: '2026-03-17T12:00:00.000Z',
+                        content: '# Notes',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        referenceNumber: 8,
+                        version: 7,
+                        taskId: 'task-1',
+                        originalFilename: 'notes.md',
+                        linkRole: 'attachment'
+                    }
+                ]
+            });
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'document-upsert',
+                    path: 'workspaces/default/assets/documents/asset-doc-1-notes.md',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    referenceNumber: 8,
+                    version: 7,
+                    taskId: 'task-1',
+                    originalFilename: 'notes.md',
+                    linkRole: 'attachment'
+                })
+            ]));
+        });
+        it('emits asset-upsert and asset-delete changes for binary assets', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                assets: [
+                    {
+                        path: 'workspaces/default/assets/images/asset-image-1-diagram.png',
+                        updatedAt: '2026-03-17T12:00:00.000Z',
+                        contentBase64: 'aW1hZ2UtYnl0ZXM=',
+                        assetId: 'asset-image-1',
+                        kind: 'image',
+                        mimeType: 'image/png',
+                        taskId: 'task-1',
+                        originalFilename: 'diagram.png',
+                        linkRole: 'image'
+                    }
+                ],
+                lastPushedAssetPaths: new Set(['workspaces/default/assets/images/asset-image-1-diagram.png', 'workspaces/default/assets/files/asset-file-old-document.pdf'])
+            });
+            expect(Array.from(payload.currentAssetPaths)).toEqual(['workspaces/default/assets/images/asset-image-1-diagram.png']);
+            expect(Array.from(payload.deleteAssetPaths)).toEqual(['workspaces/default/assets/files/asset-file-old-document.pdf']);
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'asset-upsert',
+                    path: 'workspaces/default/assets/images/asset-image-1-diagram.png',
+                    assetId: 'asset-image-1',
+                    kind: 'image',
+                    linkRole: 'image'
+                }),
+                expect.objectContaining({
+                    op: 'asset-delete',
+                    path: 'workspaces/default/assets/files/asset-file-old-document.pdf'
+                })
+            ]));
+        });
+        it('orders task upserts deterministically by task id', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [
+                    {
+                        id: 'parent-1',
+                        title: 'Parent',
+                        status: 'done',
+                        createdAt: '2026-03-15T12:00:00.000Z',
+                        updatedAt: '2026-03-15T12:05:00.000Z'
+                    },
+                    {
+                        id: 'child-1',
+                        title: 'Child',
+                        status: 'done',
+                        createdAt: '2026-03-15T12:00:00.000Z',
+                        updatedAt: '2026-03-15T12:04:00.000Z'
+                    }
+                ],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set()
+            });
+            const upserts = payload.changes
+                .filter((change) => change.op === 'upsert')
+                .map((change) => (change.op === 'upsert' ? String(change.task.id) : ''));
+            expect(upserts).toEqual(['child-1', 'parent-1']);
+        });
+        it('emits ai-profile-upsert changes and tracks ai profile watermarks', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                aiProfiles: [
+                    {
+                        id: 'ai-profile-1',
+                        workspaceId: 'ws-1',
+                        profileToken: 'tfp_test',
+                        name: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        surfaceType: 'coding_tool',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        updatedAt: '2026-03-22T10:05:00.000Z',
+                        lastActiveAt: '2026-03-22T10:05:00.000Z'
+                    }
+                ]
+            });
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'ai-profile-upsert',
+                    profile: expect.objectContaining({
+                        id: 'ai-profile-1',
+                        name: 'Codex',
+                        surfaceType: 'coding_tool'
+                    })
+                })
+            ]));
+            expect(Array.from(payload.currentAiProfileIds)).toEqual(['ai-profile-1']);
+            expect(payload.currentAiProfileWatermarks.get('ai-profile-1')).toBe('2026-03-22T10:05:00.000Z');
+        });
+        it('filters unchanged ai profiles when ai watermark state already matches', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                aiProfiles: [
+                    {
+                        id: 'ai-profile-1',
+                        workspaceId: 'ws-1',
+                        profileToken: 'tfp_test',
+                        name: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        surfaceType: 'coding_tool',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        updatedAt: '2026-03-22T10:05:00.000Z',
+                        lastActiveAt: '2026-03-22T10:05:00.000Z'
+                    }
+                ],
+                lastPushedAiProfileIds: new Set(['ai-profile-1']),
+                lastPushedAiProfileWatermarks: new Map([['ai-profile-1', '2026-03-22T10:05:00.000Z']])
+            });
+            expect(payload.changes.some((change) => change.op === 'ai-profile-upsert')).toBe(false);
+            expect(Array.from(payload.currentAiProfileIds)).toEqual(['ai-profile-1']);
+        });
+        it('emits initiative and workstream upserts and tracks their watermarks', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                initiatives: [{
+                        id: 'initiative-1',
+                        referenceNumber: 12,
+                        referenceLabel: 'IN-12',
+                        title: 'Revenue Expansion',
+                        description: 'Grow subscription revenue',
+                        ownerId: 'user-1',
+                        createdAt: '2026-03-29T10:00:00.000Z',
+                        updatedAt: '2026-03-29T11:00:00.000Z',
+                        order: 1,
+                        isArchived: false
+                    }],
+                workstreams: [{
+                        id: 'workstream-1',
+                        referenceNumber: 4,
+                        referenceLabel: 'WS-4',
+                        initiativeId: 'initiative-1',
+                        title: 'Checkout UX',
+                        description: 'Improve payment flow',
+                        ownerId: 'user-2',
+                        createdAt: '2026-03-29T10:30:00.000Z',
+                        updatedAt: '2026-03-29T11:30:00.000Z',
+                        order: 2,
+                        isArchived: false
+                    }]
+            });
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'initiative-upsert',
+                    initiative: expect.objectContaining({
+                        id: 'initiative-1',
+                        title: 'Revenue Expansion'
+                    })
+                }),
+                expect.objectContaining({
+                    op: 'workstream-upsert',
+                    workstream: expect.objectContaining({
+                        id: 'workstream-1',
+                        initiativeId: 'initiative-1',
+                        title: 'Checkout UX'
+                    })
+                })
+            ]));
+            expect(Array.from(payload.currentInitiativeIds)).toEqual(['initiative-1']);
+            expect(Array.from(payload.currentWorkstreamIds)).toEqual(['workstream-1']);
+            expect(payload.currentInitiativeWatermarks.get('initiative-1')).toBe('2026-03-29T11:00:00.000Z');
+            expect(payload.currentWorkstreamWatermarks.get('workstream-1')).toBe('2026-03-29T11:30:00.000Z');
+        });
+        it('filters unchanged initiative and workstream upserts when watermarks already match', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                initiatives: [{
+                        id: 'initiative-1',
+                        title: 'Revenue Expansion',
+                        description: null,
+                        createdAt: '2026-03-29T10:00:00.000Z',
+                        updatedAt: '2026-03-29T11:00:00.000Z'
+                    }],
+                workstreams: [{
+                        id: 'workstream-1',
+                        initiativeId: 'initiative-1',
+                        title: 'Checkout UX',
+                        description: null,
+                        createdAt: '2026-03-29T10:30:00.000Z',
+                        updatedAt: '2026-03-29T11:30:00.000Z'
+                    }],
+                lastPushedInitiativeWatermarks: new Map([['initiative-1', '2026-03-29T11:00:00.000Z']]),
+                lastPushedWorkstreamWatermarks: new Map([['workstream-1', '2026-03-29T11:30:00.000Z']])
+            });
+            expect(payload.changes.some((change) => change.op === 'initiative-upsert')).toBe(false);
+            expect(payload.changes.some((change) => change.op === 'workstream-upsert')).toBe(false);
+            expect(Array.from(payload.currentInitiativeIds)).toEqual(['initiative-1']);
+            expect(Array.from(payload.currentWorkstreamIds)).toEqual(['workstream-1']);
+        });
+        it('includes unattached annotated attachment sessions in sync payloads', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                annotatedAttachmentSessions: [
+                    {
+                        id: 'session-unattached-1',
+                        workspaceId: 'ws-1',
+                        taskId: '',
+                        baseImageAssetId: 'asset-image-1',
+                        title: 'Loose image notes',
+                        globalInstruction: null,
+                        annotations: [],
+                        createdByActorId: null,
+                        updatedByActorId: null,
+                        createdAt: '2026-03-30T00:00:00.000Z',
+                        updatedAt: '2026-03-30T00:05:00.000Z',
+                        deletedAt: null
+                    }
+                ]
+            });
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'annotated-attachment-session-upsert',
+                    session: expect.objectContaining({
+                        id: 'session-unattached-1',
+                        taskId: '',
+                        baseImageAssetId: 'asset-image-1'
+                    })
+                })
+            ]));
+            expect(Array.from(payload.currentAnnotatedAttachmentSessionIds)).toEqual(['session-unattached-1']);
+            expect(payload.currentAnnotatedAttachmentSessionWatermarks.get('session-unattached-1')).toBe('2026-03-30T00:05:00.000Z');
+        });
+        it('includes all ai profiles when ai watermark state is intentionally reset', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                aiProfiles: [
+                    {
+                        id: 'ai-profile-1',
+                        workspaceId: 'ws-1',
+                        profileToken: 'tfp_test',
+                        name: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        updatedAt: '2026-03-22T10:05:00.000Z',
+                        lastActiveAt: '2026-03-22T10:05:00.000Z'
+                    }
+                ],
+                lastPushedAiProfileIds: new Set(),
+                lastPushedAiProfileWatermarks: new Map()
+            });
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'ai-profile-upsert',
+                    profile: expect.objectContaining({
+                        id: 'ai-profile-1'
+                    })
+                })
+            ]));
+        });
+        it('emits document review session upserts and deletes with watermark tracking', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                documentReviewSessions: [
+                    {
+                        id: 'review-keep',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 2,
+                        title: 'Review',
+                        status: 'open',
+                        comments: [],
+                        createdByActorId: null,
+                        updatedByActorId: null,
+                        createdAt: '2026-03-24T10:00:00.000Z',
+                        updatedAt: '2026-03-24T10:05:00.000Z',
+                        deletedAt: null
+                    }
+                ],
+                lastPushedDocumentReviewSessionIds: new Set(['review-keep', 'review-delete']),
+                lastPushedDocumentReviewSessionWatermarks: new Map([
+                    ['review-delete', '2026-03-23T10:00:00.000Z']
+                ])
+            });
+            expect(Array.from(payload.currentDocumentReviewSessionIds)).toEqual(['review-keep']);
+            expect(Array.from(payload.deleteDocumentReviewSessionIds)).toEqual(['review-delete']);
+            expect(payload.currentDocumentReviewSessionWatermarks.get('review-keep')).toBe('2026-03-24T10:05:00.000Z');
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'document-review-session-upsert',
+                    session: expect.objectContaining({ id: 'review-keep', assetId: 'asset-doc-1' })
+                }),
+                expect.objectContaining({
+                    op: 'document-review-session-delete',
+                    sessionId: 'review-delete'
+                })
+            ]));
+        });
+        it('emits document review comment upserts and deletes with watermark tracking', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(),
+                pendingDeletedTaskIds: new Set(),
+                documentReviewComments: [
+                    {
+                        id: 'comment-keep',
+                        sessionId: 'review-1',
+                        body: 'Keep this note.',
+                        anchor: { kind: 'document' },
+                        order: 0,
+                        authorActorId: null,
+                        createdAt: '2026-03-24T10:00:00.000Z',
+                        updatedAt: '2026-03-24T10:05:00.000Z',
+                        deletedAt: null
+                    }
+                ],
+                lastPushedDocumentReviewCommentIds: new Set(['comment-keep', 'comment-delete']),
+                lastPushedDocumentReviewCommentWatermarks: new Map([
+                    ['comment-delete', '2026-03-23T10:00:00.000Z']
+                ])
+            });
+            expect(Array.from(payload.currentDocumentReviewCommentIds)).toEqual(['comment-keep']);
+            expect(Array.from(payload.deleteDocumentReviewCommentIds)).toEqual(['comment-delete']);
+            expect(payload.currentDocumentReviewCommentWatermarks.get('comment-keep')).toBe('2026-03-24T10:05:00.000Z');
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'document-review-comment-upsert',
+                    comment: expect.objectContaining({ id: 'comment-keep', sessionId: 'review-1' })
+                }),
+                expect.objectContaining({
+                    op: 'document-review-comment-delete',
+                    commentId: 'comment-delete'
+                })
+            ]));
+        });
     });
     describe('buildWorkspaceSyncSignatureModel', () => {
         it('includes pending delete operations in the signature hash', () => {
@@ -69,5 +460,256 @@ describe('workspaceSyncModel', () => {
             expect(parsedWithDeletes.pendingDeletes).toEqual(['task-2']);
             expect(noDeletes).not.toEqual(withDeletes);
         });
+        it('changes when status changes even if task membership does not', () => {
+            const baseTask = {
+                id: 'task-1',
+                title: 'Task 1',
+                status: 'task',
+                updatedAt: '2026-03-16T10:00:00.000Z'
+            };
+            const baseSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [baseTask],
+                archivedTasks: [],
+                pendingDeletedTaskIds: new Set()
+            });
+            const inProgressSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [{ ...baseTask, status: 'in-progress' }],
+                archivedTasks: [],
+                pendingDeletedTaskIds: new Set()
+            });
+            expect(inProgressSignature).not.toEqual(baseSignature);
+        });
+        it('changes when synced ai profile identity changes', () => {
+            const baseSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                aiProfiles: [{
+                        id: 'ai-profile-1',
+                        workspaceId: 'ws-1',
+                        profileToken: 'tfp_test',
+                        name: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        updatedAt: '2026-03-22T10:05:00.000Z'
+                    }]
+            });
+            const renamedSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                aiProfiles: [{
+                        id: 'ai-profile-1',
+                        workspaceId: 'ws-1',
+                        profileToken: 'tfp_test',
+                        name: 'Codex 2',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        updatedAt: '2026-03-22T10:06:00.000Z'
+                    }]
+            });
+            expect(renamedSignature).not.toEqual(baseSignature);
+        });
+        it('keeps ai profile fingerprint stable when surfaceType stays null', () => {
+            const baseSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                aiProfiles: [{
+                        id: 'ai-profile-1',
+                        workspaceId: 'ws-1',
+                        profileToken: 'tfp_test',
+                        name: 'John Drake',
+                        username: 'john-drake',
+                        icon: 'Bot',
+                        color: '#64748b',
+                        surfaceType: null,
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        updatedAt: '2026-03-22T10:05:00.000Z'
+                    }]
+            });
+            const repeatedNullSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                aiProfiles: [{
+                        id: 'ai-profile-1',
+                        workspaceId: 'ws-1',
+                        profileToken: 'tfp_test',
+                        name: 'John Drake',
+                        username: 'john-drake',
+                        icon: 'Bot',
+                        color: '#64748b',
+                        surfaceType: null,
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        updatedAt: '2026-03-22T10:05:00.000Z'
+                    }]
+            });
+            expect(repeatedNullSignature).toEqual(baseSignature);
+        });
+        it('changes when initiative or workstream state changes', () => {
+            const baseSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                initiatives: [{
+                        id: 'initiative-1',
+                        title: 'Revenue Expansion',
+                        description: null,
+                        createdAt: '2026-03-29T10:00:00.000Z',
+                        updatedAt: '2026-03-29T11:00:00.000Z'
+                    }],
+                workstreams: [{
+                        id: 'workstream-1',
+                        initiativeId: 'initiative-1',
+                        title: 'Checkout UX',
+                        description: null,
+                        createdAt: '2026-03-29T10:30:00.000Z',
+                        updatedAt: '2026-03-29T11:30:00.000Z'
+                    }]
+            });
+            const changedSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                initiatives: [{
+                        id: 'initiative-1',
+                        title: 'Revenue Expansion v2',
+                        description: null,
+                        createdAt: '2026-03-29T10:00:00.000Z',
+                        updatedAt: '2026-03-29T11:05:00.000Z'
+                    }],
+                workstreams: [{
+                        id: 'workstream-1',
+                        initiativeId: 'initiative-1',
+                        title: 'Checkout UX',
+                        description: null,
+                        createdAt: '2026-03-29T10:30:00.000Z',
+                        updatedAt: '2026-03-29T11:30:00.000Z'
+                    }]
+            });
+            expect(changedSignature).not.toEqual(baseSignature);
+        });
+        it('changes when document review sessions change', () => {
+            const baseSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                documentReviewSessions: [{
+                        id: 'review-1',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 1,
+                        title: 'Review',
+                        status: 'open',
+                        comments: [],
+                        createdByActorId: null,
+                        updatedByActorId: null,
+                        createdAt: '2026-03-24T10:00:00.000Z',
+                        updatedAt: '2026-03-24T10:05:00.000Z',
+                        deletedAt: null
+                    }]
+            });
+            const changedSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                documentReviewSessions: [{
+                        id: 'review-1',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 1,
+                        title: 'Review',
+                        status: 'resolved',
+                        comments: [{
+                                id: 'comment-1',
+                                order: 0,
+                                body: 'Updated',
+                                anchor: null,
+                                authorActorId: null,
+                                createdAt: '2026-03-24T10:00:00.000Z',
+                                updatedAt: '2026-03-24T10:05:00.000Z',
+                                deletedAt: null
+                            }],
+                        createdByActorId: null,
+                        updatedByActorId: null,
+                        createdAt: '2026-03-24T10:00:00.000Z',
+                        updatedAt: '2026-03-24T10:06:00.000Z',
+                        deletedAt: null
+                    }]
+            });
+            expect(changedSignature).not.toEqual(baseSignature);
+        });
+        it('changes when document review comments change', () => {
+            const baseSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                documentReviewComments: [{
+                        id: 'comment-1',
+                        sessionId: 'review-1',
+                        body: 'Original',
+                        anchor: null,
+                        order: 0,
+                        authorActorId: null,
+                        createdAt: '2026-03-24T10:00:00.000Z',
+                        updatedAt: '2026-03-24T10:05:00.000Z',
+                        deletedAt: null
+                    }]
+            });
+            const changedSignature = buildWorkspaceSyncSignatureModel({
+                workspaceId: 'ws-1',
+                tasks: [],
+                archivedTasks: [],
+                documentReviewComments: [{
+                        id: 'comment-1',
+                        sessionId: 'review-1',
+                        body: 'Updated',
+                        anchor: null,
+                        order: 0,
+                        authorActorId: null,
+                        createdAt: '2026-03-24T10:00:00.000Z',
+                        updatedAt: '2026-03-24T10:06:00.000Z',
+                        deletedAt: null
+                    }]
+            });
+            expect(changedSignature).not.toEqual(baseSignature);
+        });
+    });
+    describe('dirty task watermarks', () => {
+        it('emits an upsert when a status-only server-confirmed update changes updatedAt', () => {
+            const payload = buildWorkspaceSyncPayloadModel({
+                tasks: [{
+                        id: 'task-1',
+                        title: 'Task 1',
+                        status: 'in-progress',
+                        createdAt: '2026-03-16T10:00:00.000Z',
+                        updatedAt: '2026-03-16T10:05:00.000Z'
+                    }],
+                archivedTasks: [],
+                lastPushedTaskIds: new Set(['task-1']),
+                pendingDeletedTaskIds: new Set(),
+                lastPushedWatermarks: new Map([
+                    ['task-1', '2026-03-16T10:00:00.000Z']
+                ])
+            });
+            expect(payload.changes).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'upsert',
+                    archived: false,
+                    task: expect.objectContaining({
+                        id: 'task-1',
+                        status: 'in-progress'
+                    })
+                })
+            ]));
+            expect(payload.pushedWatermarks.get('task-1')).toBe('2026-03-16T10:05:00.000Z');
+        });
     });
 });

package/dist/sync/workspaceSyncState.d.ts

@@ -0,0 +1,12 @@
+export type WorkspaceSyncPhase = 'idle' | 'provision-local' | 'attach-cloud' | 'active' | 'error';
+export interface WorkspaceSyncStateV2 {
+    version: 2;
+    enabled: boolean;
+    phase: WorkspaceSyncPhase;
+    pullCursor: string | null;
+    lastPullAt: string | null;
+    lastPushAt: string | null;
+    lastSyncedAt: string | null;
+    lastErrorMessage: string | null;
+}
+export declare function createDefaultWorkspaceSyncState(): WorkspaceSyncStateV2;

package/dist/sync/workspaceSyncState.js

@@ -0,0 +1,12 @@
+export function createDefaultWorkspaceSyncState() {
+    return {
+        version: 2,
+        enabled: false,
+        phase: 'idle',
+        pullCursor: null,
+        lastPullAt: null,
+        lastPushAt: null,
+        lastSyncedAt: null,
+        lastErrorMessage: null
+    };
+}