@taskforcehq/taskforce 0.3.311 → 0.3.313

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

@@ -1,611 +0,0 @@
-import { describe, expect, it } from 'vitest';
-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({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-describe('TaskforceCore id policy', () => {
-    it('rejects client-supplied task id for normal create', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            expect(() => core.createTask({
-                id: 'task-client-provided',
-                title: 'Should fail'
-            })).toThrowError(/task id is not allowed/i);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('allows client-supplied task id in workspace sync snapshot apply path', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const result = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-imported',
-                        title: 'Imported',
-                        status: 'task'
-                    }
-                ]
-            }, 'workspace-test');
-            expect(result.created).toBe(1);
-            const task = core.getTask('task-sync-imported', 'workspace-test');
-            expect(task?.title).toBe('Imported');
-        }
-        finally {
-            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('assigns provisional local task references without consuming canonical task references', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const provisionalFirst = core.createTask({ title: 'Offline first' }, {
-                workspaceId: 'workspace-a',
-                provisionalLocalReference: true
-            });
-            const provisionalSecond = core.createTask({ title: 'Offline second' }, {
-                workspaceId: 'workspace-a',
-                provisionalLocalReference: true
-            });
-            const canonical = core.createTask({ title: 'Cloud-backed task' }, { workspaceId: 'workspace-a' });
-            expect(provisionalFirst.referenceNumber).toBeNull();
-            expect(provisionalFirst.localReferenceNumber).toBe(1);
-            expect(provisionalFirst.referenceLabel).toBe('LT-1');
-            expect(provisionalSecond.referenceNumber).toBeNull();
-            expect(provisionalSecond.localReferenceNumber).toBe(2);
-            expect(provisionalSecond.referenceLabel).toBe('LT-2');
-            expect(canonical.referenceNumber).toBe(1);
-            expect(canonical.localReferenceNumber).toBeNull();
-            expect(canonical.referenceLabel).toBe('T-1');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('replaces a provisional local reference with a canonical cloud reference during sync apply', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const provisional = core.createTask({ title: 'Offline draft' }, {
-                workspaceId: 'workspace-a',
-                provisionalLocalReference: true
-            });
-            expect(provisional.referenceLabel).toBe('LT-1');
-            const syncResult = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: provisional.id,
-                        title: 'Offline draft',
-                        status: 'task',
-                        referenceNumber: 7,
-                        updatedAt: '2099-04-10T17:00:00.000Z'
-                    }
-                ]
-            }, 'workspace-a');
-            expect(syncResult.updated).toBe(1);
-            expect(core.getTask(provisional.id, 'workspace-a')).toEqual(expect.objectContaining({
-                referenceNumber: 7,
-                localReferenceNumber: null,
-                referenceLabel: 'T-7'
-            }));
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('preserves provisional local references across core reloads', () => {
-        const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-id-reload-test-'));
-        const storagePath = path.join(projectRoot, '.taskforce');
-        const firstCore = new TaskforceCore({ projectRoot, storagePath });
-        try {
-            const provisional = firstCore.createTask({ title: 'Offline draft' }, {
-                workspaceId: 'workspace-a',
-                provisionalLocalReference: true
-            });
-            expect(provisional.referenceNumber).toBeNull();
-            expect(provisional.localReferenceNumber).toBe(1);
-            firstCore.close();
-            const reloadedCore = new TaskforceCore({ projectRoot, storagePath });
-            try {
-                const reloadedTask = reloadedCore.getTask(provisional.id, 'workspace-a');
-                expect(reloadedTask).toEqual(expect.objectContaining({
-                    referenceNumber: null,
-                    localReferenceNumber: 1,
-                    referenceLabel: 'LT-1'
-                }));
-            }
-            finally {
-                reloadedCore.close();
-            }
-        }
-        finally {
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('lets the incoming synced task keep its preferred reference and renumbers the local incumbent', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const localTask = core.createTask({ title: 'Local task' }, { workspaceId: 'workspace-a' });
-            const syncResult = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-imported-collision',
-                        title: 'Remote task',
-                        status: 'task',
-                        referenceNumber: localTask.referenceNumber,
-                        createdAt: '2026-04-10T15:00:00.000Z',
-                        updatedAt: '2026-04-10T15:00:00.000Z',
-                    }
-                ]
-            }, 'workspace-a');
-            expect(syncResult.created).toBe(1);
-            expect(core.getTask(localTask.id, 'workspace-a')?.referenceLabel).toBe('T-2');
-            expect(core.getTask('task-sync-imported-collision', 'workspace-a')?.referenceLabel).toBe('T-1');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('lets incoming synced updates claim the preferred reference and renumbers the displaced task', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const first = core.createTask({ title: 'First' }, { workspaceId: 'workspace-a' });
-            const second = core.createTask({ title: 'Second' }, { workspaceId: 'workspace-a' });
-            const syncResult = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: second.id,
-                        title: 'Second',
-                        status: 'task',
-                        referenceNumber: first.referenceNumber,
-                        updatedAt: '2099-04-11T16:00:00.000Z',
-                    }
-                ]
-            }, 'workspace-a');
-            expect(syncResult.updated).toBe(1);
-            expect(core.getTask(first.id, 'workspace-a')?.referenceLabel).toBe('T-3');
-            expect(core.getTask(second.id, 'workspace-a')?.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 {
-            core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-conflict-1',
-                        title: 'Local newer',
-                        status: 'task',
-                        createdAt: '2026-02-20T10:00:00.000Z'
-                    }
-                ]
-            }, 'workspace-test');
-            const staleResult = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-conflict-1',
-                        title: 'Cloud stale',
-                        status: 'task',
-                        updatedAt: '2026-02-20T09:00:00.000Z'
-                    }
-                ]
-            }, 'workspace-test');
-            expect(staleResult.skipped).toBe(1);
-            const task = core.getTask('task-sync-conflict-1', 'workspace-test');
-            expect(task?.title).toBe('Local newer');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('applies newer incoming sync update when timestamp is later', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-conflict-2',
-                        title: 'Old value',
-                        status: 'task',
-                        createdAt: '2026-02-20T10:00:00.000Z'
-                    }
-                ]
-            }, 'workspace-test');
-            const newerResult = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-conflict-2',
-                        title: 'Newer value',
-                        status: 'in-progress',
-                        updatedAt: '2026-02-20T11:00:00.000Z'
-                    }
-                ]
-            }, 'workspace-test');
-            expect(newerResult.updated).toBe(1);
-            const task = core.getTask('task-sync-conflict-2', 'workspace-test');
-            expect(task?.title).toBe('Newer value');
-            expect(task?.status).toBe('in-progress');
-        }
-        finally {
-            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 removalSnapshotResult = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-comments-update',
-                        title: 'Comment sync task',
-                        status: 'task',
-                        updatedAt: '2026-02-20T12:00:00.000Z',
-                        comments: [
-                            {
-                                id: 'comment-new',
-                                author: 'ai',
-                                text: 'Newer synced comment',
-                                timestamp: '2026-02-20T11:00:00.000Z'
-                            }
-                        ]
-                    }
-                ]
-            }, 'workspace-test');
-            expect(removalSnapshotResult.updated).toBe(1);
-            expect(core.getTask('task-sync-comments-update', 'workspace-test')?.comments).toEqual([
-                expect.objectContaining({
-                    id: 'comment-new',
-                    text: 'Newer synced comment',
-                })
-            ]);
-            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('keeps task sync watermarks monotonic when adding comments', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({
-                title: 'Comment watermark task',
-                status: 'task'
-            }, { workspaceId: 'workspace-test' });
-            const futureWatermark = '2099-02-20T10:00:00.000Z';
-            const db = core.db;
-            db.prepare(`
-                UPDATE tasks
-                SET updated_at = ?
-                WHERE tenant_id = ? AND workspace_id = ? AND id = ?
-            `).run(futureWatermark, 'default', 'workspace-test', task.id);
-            const updated = core.addComment(task.id, 'Comment should advance sync', 'user', 'workspace-test');
-            expect(Date.parse(String(updated?.updatedAt || ''))).toBeGreaterThan(Date.parse(futureWatermark));
-            const syncRows = core.listTasksForSync('workspace-test', {
-                watermark: futureWatermark,
-                id: task.id
-            }, 10);
-            expect(syncRows).toHaveLength(1);
-            expect(syncRows[0]?.task.comments).toEqual([
-                expect.objectContaining({
-                    author: 'user',
-                    submittedAuthor: 'user',
-                    text: 'Comment should advance sync'
-                })
-            ]);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('applies incoming sync update when timestamps are equal (deterministic tie behavior)', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-conflict-3',
-                        title: 'Initial value',
-                        status: 'task',
-                        createdAt: '2026-02-20T10:00:00.000Z'
-                    }
-                ]
-            }, 'workspace-test');
-            const equalTimestampResult = core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    {
-                        id: 'task-sync-conflict-3',
-                        title: 'zz-incoming-same-timestamp',
-                        status: 'review',
-                        createdAt: '2026-02-20T10:00:00.000Z',
-                        updatedAt: '2026-02-20T10:00:00.000Z'
-                    }
-                ]
-            }, 'workspace-test');
-            expect(equalTimestampResult.updated).toBe(1);
-            const task = core.getTask('task-sync-conflict-3', 'workspace-test');
-            expect(task?.title).toBe('zz-incoming-same-timestamp');
-            expect(task?.status).toBe('review');
-        }
-        finally {
-            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 {
-            core.applyWorkspaceSyncSnapshot({
-                tasks: [{ id: 'task-a', title: 'A', status: 'task' }]
-            }, 'workspace-small');
-            core.applyWorkspaceSyncSnapshot({
-                tasks: [
-                    { id: 'task-b1', title: 'B1', status: 'task' },
-                    { id: 'task-b2', title: 'B2', status: 'task' }
-                ]
-            }, 'workspace-large');
-            expect(core.resolvePreferredWorkspaceId({ allowDefault: true })).toBe('workspace-large');
-            expect(core.resolvePreferredWorkspaceId({ allowDefault: false })).toBe('workspace-large');
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

package/dist/core/Taskforce.listTasksSlim.test.d.ts

@@ -1 +0,0 @@
-export {};