@taskforcehq/taskforce 0.3.301 → 0.3.302

package/dist/server/routes/sync.integration.test.js

@@ -140,6 +140,49 @@ describe('Server Routes Workspace Sync Integration', () => {
         expect(task?.status).toBe('in-progress');
         expect(defaultWorkspaceTasks.find((item) => item.id === 'task-cloud-1')).toBeUndefined();
     });
+    it('lets the cloud task keep a colliding reference number during apply-local and records a diagnostic', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-task-ref-collision-');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId, name: 'Local Active Workspace' });
+        const localTask = core.createTask({ title: 'Local incumbent' }, { workspaceId });
+        expect(localTask.referenceLabel).toBe('T-1');
+        const routes = createRoutes(core, { authConfig: { runtimeMode: 'local', enabled: false } });
+        const match = matchRoute('POST', '/api/taskforce/sync/workspace/apply-local', routes);
+        expect(match).toBeTruthy();
+        const req = createMockReq('POST', '/api/taskforce/sync/workspace/apply-local', {
+            changes: [
+                {
+                    op: 'upsert',
+                    archived: false,
+                    task: {
+                        id: 'task-cloud-ref-1',
+                        title: 'Cloud winner',
+                        status: 'task',
+                        referenceNumber: 1,
+                        updatedAt: '2026-04-10T16:00:00.000Z'
+                    }
+                }
+            ]
+        }, { 'x-taskforce-workspace-id': workspaceId });
+        const res = createMockRes();
+        await match?.handler(req, res, {});
+        expect(res.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        expect(reloadedCore.getTask('task-cloud-ref-1', workspaceId)?.referenceLabel).toBe('T-1');
+        expect(reloadedCore.getTask(localTask.id, workspaceId)?.referenceLabel).toBe('T-2');
+        expect(reloadedCore.listSyncEvents(workspaceId, 10)).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                eventType: 'apply',
+                status: 'error',
+                errorMessage: 'Detected task reference number mismatch during normal sync.',
+                details: expect.objectContaining({
+                    referenceLabel: 'T-1',
+                    existingTaskId: localTask.id,
+                    taskId: 'task-cloud-ref-1'
+                })
+            })
+        ]));
+    });
     it('persists synced comments via apply-local route', async () => {
         const projectRoot = createIsolatedProjectRoot('taskforce-sync-apply-comments-');
         const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
@@ -1487,6 +1530,93 @@ describe('Server Routes Workspace Sync Integration', () => {
             })
         ]);
     });
+    it('omits local provisional reference fields from authenticated pull payloads', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-pull-task-ref-payload-');
+        const seedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        seedAuthenticatedWorkspace(seedCore);
+        const created = seedCore.createTask({
+            title: 'Offline draft',
+            status: 'task'
+        }, {
+            workspaceId,
+            provisionalLocalReference: true
+        });
+        expect(created.localReferenceNumber).toBe(1);
+        expect(created.referenceLabel).toBe('LT-1');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const routes = createRoutes(core, { authConfig });
+        const pullMatch = matchRoute('GET', '/api/taskforce/sync/workspace/pull', routes);
+        expect(pullMatch).toBeTruthy();
+        const cookie = createAuthCookie(workspaceId);
+        const pullReq = createMockReq('GET', '/api/taskforce/sync/workspace/pull?workspaceId=workspace-local-active&limit=200', undefined, { cookie });
+        const pullRes = createMockRes();
+        await pullMatch?.handler(pullReq, pullRes, {});
+        expect(pullRes.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const pullBody = readJsonBody(pullRes);
+        const upsert = (Array.isArray(pullBody?.changes) ? pullBody.changes : [])
+            .find((change) => change?.op === 'upsert' && change?.task?.id === created.id);
+        expect(upsert?.task).toEqual(expect.objectContaining({
+            id: created.id,
+            title: 'Offline draft',
+            referenceNumber: null
+        }));
+        expect(upsert?.task).not.toHaveProperty('localReferenceNumber');
+        expect(upsert?.task).not.toHaveProperty('referenceLabel');
+    });
+    it('returns a pushed provisional task on pull even when the caller cursor is newer than the stale local watermark', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-push-pull-provisional-task-');
+        const seedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        seedAuthenticatedWorkspace(seedCore);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const routes = createRoutes(core, { authConfig });
+        const pushMatch = matchRoute('POST', '/api/taskforce/sync/workspace/push', routes);
+        const pullMatch = matchRoute('GET', '/api/taskforce/sync/workspace/pull', routes);
+        expect(pushMatch).toBeTruthy();
+        expect(pullMatch).toBeTruthy();
+        const cookie = createAuthCookie(workspaceId);
+        const taskId = 'task-provisional-roundtrip-1';
+        const staleUpdatedAt = '2026-04-11T21:29:04.121Z';
+        const pushReq = createMockReq('POST', '/api/taskforce/sync/workspace/push', {
+            workspaceId,
+            idempotencyKey: 'task-provisional-roundtrip-1',
+            changes: [
+                {
+                    op: 'upsert',
+                    archived: false,
+                    task: {
+                        id: taskId,
+                        title: 'Offline provisional task',
+                        status: 'task',
+                        createdAt: '2026-04-11T21:28:52.410Z',
+                        updatedAt: staleUpdatedAt,
+                        referenceNumber: null
+                    }
+                }
+            ]
+        }, { cookie });
+        const pushRes = createMockRes();
+        await pushMatch?.handler(pushReq, pushRes, {});
+        expect(pushRes.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const persisted = core.getTask(taskId, workspaceId);
+        expect(persisted?.referenceNumber).toBe(1);
+        expect(Date.parse(String(persisted?.updatedAt || ''))).toBeGreaterThan(Date.parse(staleUpdatedAt));
+        const cursor = Buffer.from(JSON.stringify({
+            u: '2026-04-11T21:29:05.000Z',
+            id: 'seed'
+        })).toString('base64url');
+        const pullReq = createMockReq('GET', `/api/taskforce/sync/workspace/pull?workspaceId=${workspaceId}&limit=200&cursor=${cursor}`, undefined, { cookie });
+        const pullRes = createMockRes();
+        await pullMatch?.handler(pullReq, pullRes, {});
+        expect(pullRes.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const pullBody = readJsonBody(pullRes);
+        const upsert = (Array.isArray(pullBody?.changes) ? pullBody.changes : [])
+            .find((change) => change?.op === 'upsert' && change?.task?.id === taskId);
+        expect(upsert?.task).toEqual(expect.objectContaining({
+            id: taskId,
+            title: 'Offline provisional task',
+            referenceNumber: 1
+        }));
+    });
     it('keeps document deleted when push batch includes upsert and delete for same path', async () => {
         const projectRoot = createIsolatedProjectRoot('taskforce-sync-push-doc-delete-wins-');
         const seedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });