@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/core/Taskforce.ids.test.js

@@ -3,6 +3,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { TaskforceCore } from './Taskforce';
+import { ensureTaskReferenceSchema } from '../migrations/taskSchemaMigrations';
 function makeCore() {
     const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-id-test-'));
     const core = new TaskforceCore({
@@ -50,6 +51,106 @@ describe('TaskforceCore id policy', () => {
             cleanup();
         }
     });
+    it('rejects client-supplied task reference number for normal create', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            expect(() => core.createTask({
+                title: 'Should fail',
+                referenceNumber: 99
+            })).toThrowError(/task reference number is not allowed/i);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('assigns sequential task references per workspace', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const first = core.createTask({ title: 'First' }, { workspaceId: 'workspace-a' });
+            const second = core.createTask({ title: 'Second' }, { workspaceId: 'workspace-a' });
+            const otherWorkspaceFirst = core.createTask({ title: 'Other workspace first' }, { workspaceId: 'workspace-b' });
+            expect(first.referenceNumber).toBe(1);
+            expect(first.referenceLabel).toBe('T-1');
+            expect(second.referenceNumber).toBe(2);
+            expect(second.referenceLabel).toBe('T-2');
+            expect(otherWorkspaceFirst.referenceNumber).toBe(1);
+            expect(otherWorkspaceFirst.referenceLabel).toBe('T-1');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('resolves task identifiers by task reference or internal id', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const created = core.createTask({ title: 'Lookup target' }, { workspaceId: 'workspace-a' });
+            expect(core.resolveTaskIdentifier('T-1', 'workspace-a')?.id).toBe(created.id);
+            expect(core.resolveTaskIdentifier(created.id, 'workspace-a')?.referenceLabel).toBe('T-1');
+            expect(core.searchTasks('T-1', 'all', 'workspace-a')[0]?.id).toBe(created.id);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('backfills missing task references deterministically and restores workspace counters', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const first = core.createTask({ title: 'First' }, { workspaceId: 'workspace-a' });
+            const second = core.createTask({ title: 'Second' }, { workspaceId: 'workspace-a' });
+            const db = core.db;
+            db.prepare(`UPDATE tasks SET reference_number = NULL WHERE tenant_id = ? AND workspace_id = ?`).run('default', 'workspace-a');
+            db.prepare(`DELETE FROM workspace_task_reference_sequences WHERE tenant_id = ? AND workspace_id = ?`).run('default', 'workspace-a');
+            ensureTaskReferenceSchema(db);
+            const refreshedFirst = core.getTask(first.id, 'workspace-a');
+            const refreshedSecond = core.getTask(second.id, 'workspace-a');
+            const third = core.createTask({ title: 'Third' }, { workspaceId: 'workspace-a' });
+            expect(refreshedFirst?.referenceLabel).toBe('T-1');
+            expect(refreshedSecond?.referenceLabel).toBe('T-2');
+            expect(third.referenceLabel).toBe('T-3');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('imports synced comments when creating a task from workspace sync snapshot', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-comments-create',
+                        title: 'Imported with comments',
+                        status: 'task',
+                        comments: [
+                            {
+                                id: 'comment-sync-1',
+                                author: 'user',
+                                text: 'Imported comment',
+                                timestamp: '2026-02-20T10:00:00.000Z'
+                            }
+                        ]
+                    }
+                ]
+            }, 'workspace-test');
+            const task = core.getTask('task-sync-comments-create', 'workspace-test');
+            expect(task?.comments).toEqual([
+                expect.objectContaining({
+                    id: 'comment-sync-1',
+                    author: 'user',
+                    submittedAuthor: 'user',
+                    text: 'Imported comment',
+                    timestamp: '2026-02-20T10:00:00.000Z',
+                    actor: expect.objectContaining({
+                        id: 'user',
+                        kind: 'human'
+                    })
+                })
+            ]);
+        }
+        finally {
+            cleanup();
+        }
+    });
     it('ignores stale incoming sync update when existing task is newer', () => {
         const { core, cleanup } = makeCore();
         try {
@@ -113,6 +214,122 @@ describe('TaskforceCore id policy', () => {
             cleanup();
         }
     });
+    it('preserves unresolved synced assignee ids instead of coercing them to unassigned', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const result = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-unresolved-assignee',
+                        title: 'Imported with opaque assignee',
+                        status: 'task',
+                        assignee: 'user-remote-1'
+                    }
+                ]
+            }, 'workspace-test');
+            expect(result.created).toBe(1);
+            const task = core.getTask('task-sync-unresolved-assignee', 'workspace-test');
+            expect(task?.assignee).toBe('user-remote-1');
+            expect(task?.assigneeActor).toEqual(expect.objectContaining({
+                id: 'user-remote-1',
+                kind: 'human',
+                meta: expect.objectContaining({ unresolved: true })
+            }));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('applies newer incoming sync comments and ignores stale incoming comment snapshots', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-comments-update',
+                        title: 'Comment sync task',
+                        status: 'task',
+                        updatedAt: '2026-02-20T10:00:00.000Z',
+                        comments: [
+                            {
+                                id: 'comment-old',
+                                author: 'user',
+                                text: 'Older comment',
+                                timestamp: '2026-02-20T10:00:00.000Z'
+                            }
+                        ]
+                    }
+                ]
+            }, 'workspace-test');
+            const newerResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-comments-update',
+                        title: 'Comment sync task',
+                        status: 'task',
+                        updatedAt: '2026-02-20T11:00:00.000Z',
+                        comments: [
+                            {
+                                id: 'comment-new',
+                                author: 'ai',
+                                text: 'Newer synced comment',
+                                timestamp: '2026-02-20T11:00:00.000Z'
+                            }
+                        ]
+                    }
+                ]
+            }, 'workspace-test');
+            expect(newerResult.updated).toBe(1);
+            expect(core.getTask('task-sync-comments-update', 'workspace-test')?.comments).toEqual([
+                expect.objectContaining({
+                    id: 'comment-new',
+                    author: 'agent',
+                    submittedAuthor: 'ai',
+                    text: 'Newer synced comment',
+                    timestamp: '2026-02-20T11:00:00.000Z',
+                    actor: expect.objectContaining({
+                        id: 'agent',
+                        kind: 'ai'
+                    })
+                })
+            ]);
+            const staleResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-comments-update',
+                        title: 'Comment sync task',
+                        status: 'task',
+                        updatedAt: '2026-02-20T10:30:00.000Z',
+                        comments: [
+                            {
+                                id: 'comment-stale',
+                                author: 'user',
+                                text: 'Stale comment',
+                                timestamp: '2026-02-20T10:30:00.000Z'
+                            }
+                        ]
+                    }
+                ]
+            }, 'workspace-test');
+            expect(staleResult.skipped).toBe(1);
+            expect(core.getTask('task-sync-comments-update', 'workspace-test')?.comments).toEqual([
+                expect.objectContaining({
+                    id: 'comment-new',
+                    author: 'agent',
+                    submittedAuthor: 'ai',
+                    text: 'Newer synced comment',
+                    timestamp: '2026-02-20T11:00:00.000Z',
+                    actor: expect.objectContaining({
+                        id: 'agent',
+                        kind: 'ai'
+                    })
+                })
+            ]);
+        }
+        finally {
+            cleanup();
+        }
+    });
     it('applies incoming sync update when timestamps are equal (deterministic tie behavior)', () => {
         const { core, cleanup } = makeCore();
         try {
@@ -146,6 +363,41 @@ describe('TaskforceCore id policy', () => {
             cleanup();
         }
     });
+    it('does not churn updatedAt when the incoming sync snapshot is identical to the winning local snapshot', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-stable',
+                        title: 'Stable task',
+                        status: 'in-progress',
+                        createdAt: '2026-02-20T10:00:00.000Z',
+                        updatedAt: '2026-02-20T11:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            const before = core.getTask('task-sync-stable', 'workspace-test');
+            const repeatedResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-stable',
+                        title: 'Stable task',
+                        status: 'in-progress',
+                        createdAt: '2026-02-20T10:00:00.000Z',
+                        updatedAt: '2026-02-20T11:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            const after = core.getTask('task-sync-stable', 'workspace-test');
+            expect(repeatedResult.skipped).toBe(1);
+            expect(after?.updatedAt).toBe(before?.updatedAt);
+            expect(after?.status).toBe('in-progress');
+        }
+        finally {
+            cleanup();
+        }
+    });
     it('resolves preferred workspace to the most active non-default workspace', () => {
         const { core, cleanup } = makeCore();
         try {