@taskforcehq/taskforce 0.3.309 → 0.3.313

package/dist/core/AuthTokenService.test.d.ts

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

package/dist/core/AuthTokenService.test.js

@@ -1,78 +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';
-function makeCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-auth-token-test-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    core.updateGlobalSettings({
-        billing: {
-            onboardingPolicy: {
-                mode: 'require_plan_selection',
-                planId: null
-            }
-        }
-    });
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'active' });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-describe('Auth token lifecycle', () => {
-    it('keeps previously issued verification tokens valid until they are used or expire', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.registerPasswordUser({
-                email: 'verify@example.com',
-                password: 'ValidPassphrase123!',
-                displayName: 'Verify User',
-                betaAccess: true
-            });
-            const first = String(core.requestEmailVerification({ email: 'verify@example.com' }).token || '');
-            const second = String(core.requestEmailVerification({ email: 'verify@example.com' }).token || '');
-            expect(first).toMatch(/^[a-f0-9]{48}$/);
-            expect(second).toMatch(/^[a-f0-9]{48}$/);
-            expect(first).not.toBe(second);
-            expect(core.inspectOneTimeAuthToken(first, 'email_verification').state).toBe('valid');
-            expect(core.inspectOneTimeAuthToken(second, 'email_verification').state).toBe('valid');
-            expect(core.verifyEmailWithToken(first)).toBe(true);
-            expect(core.inspectOneTimeAuthToken(first, 'email_verification').state).toBe('used');
-            expect(core.inspectOneTimeAuthToken(second, 'email_verification').state).toBe('valid');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('keeps previously issued password reset tokens valid until they are used or expire', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.registerPasswordUser({
-                email: 'reset@example.com',
-                password: 'ValidPassphrase123!',
-                displayName: 'Reset User',
-                betaAccess: true
-            });
-            const first = String(core.requestPasswordReset({ email: 'reset@example.com' }).token || '');
-            const second = String(core.requestPasswordReset({ email: 'reset@example.com' }).token || '');
-            expect(first).toMatch(/^[a-f0-9]{48}$/);
-            expect(second).toMatch(/^[a-f0-9]{48}$/);
-            expect(first).not.toBe(second);
-            expect(core.inspectOneTimeAuthToken(first, 'password_reset').state).toBe('valid');
-            expect(core.inspectOneTimeAuthToken(second, 'password_reset').state).toBe('valid');
-            expect(core.resetPasswordWithToken({ token: first, password: 'UpdatedPass456!' })).toBe(true);
-            expect(core.inspectOneTimeAuthToken(first, 'password_reset').state).toBe('used');
-            expect(core.inspectOneTimeAuthToken(second, 'password_reset').state).toBe('valid');
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

package/dist/core/BulkUpdateFieldsPreview.test.d.ts

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

package/dist/core/BulkUpdateFieldsPreview.test.js

@@ -1,62 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TaskforceCore } from './Taskforce';
-function makeTempProjectRoot() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-bulk-preview-'));
-    fs.mkdirSync(root, { recursive: true });
-    return root;
-}
-describe('TaskforceCore bulk update preflight', () => {
-    it('builds deterministic apply set and skips invalid/noop updates', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({ title: 'A', priority: 2 });
-        const preview = core.bulkUpdateFieldsPreview([
-            { title: 'missing id' },
-            { id: 'task-missing', title: 'x' },
-            { id: task.id, priority: 2 }, // no-op
-            { id: task.id, priority: 3 } // apply
-        ]);
-        expect(preview.total).toBe(4);
-        expect(preview.toApply).toHaveLength(1);
-        expect(preview.toApply[0].id).toBe(task.id);
-        expect(preview.toApply[0].changedFields).toEqual(['priority']);
-        expect(preview.skipped.map(s => s.code)).toEqual(expect.arrayContaining(['TASK_ID_REQUIRED', 'TASK_NOT_FOUND', 'DUPLICATE_SUPERSEDED']));
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('applies only changed fields and returns skip counters', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({ title: 'A', priority: 2 });
-        const result = core.bulkUpdateFields([
-            { id: task.id, priority: 2 }, // no-op
-            { id: task.id, priority: 3 }, // superseded
-            { id: task.id, priority: 4 } // effective
-        ]);
-        const refreshed = core.getTask(task.id);
-        expect(refreshed?.priority).toBe(4);
-        expect(result.updated).toBe(1);
-        expect(result.skippedNoop).toBe(2);
-        expect(result.deduped).toBe(2);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('includes priority distribution before and after', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const a = core.createTask({ title: 'A', priority: 1 });
-        core.createTask({ title: 'B', priority: 2 });
-        const preview = core.bulkUpdateFieldsPreview([
-            { id: a.id, priority: 4 }
-        ]);
-        expect(preview.priorityBefore?.[1]).toBe(1);
-        expect(preview.priorityBefore?.[4] || 0).toBe(0);
-        expect(preview.priorityAfter?.[1] || 0).toBe(0);
-        expect(preview.priorityAfter?.[4]).toBe(1);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-});

package/dist/core/CompletedAt.test.d.ts

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

package/dist/core/CompletedAt.test.js

@@ -1,44 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { TaskforceCore } from './Taskforce';
-const roots = [];
-function createCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-completed-at-'));
-    roots.push(projectRoot);
-    return new TaskforceCore({ projectRoot });
-}
-afterEach(() => {
-    while (roots.length > 0) {
-        const root = roots.pop();
-        if (root)
-            fs.rmSync(root, { recursive: true, force: true });
-    }
-});
-describe('TaskforceCore completedAt behavior', () => {
-    it('sets completedAt when status transitions to done', () => {
-        const core = createCore();
-        const task = core.createTask({ title: 'A', status: 'task' });
-        const updated = core.updateTask(task.id, { status: 'done' });
-        expect(updated?.completedAt).toBeTruthy();
-        core.close();
-    });
-    it('preserves completedAt when archiving a previously completed task', () => {
-        const core = createCore();
-        const task = core.createTask({ title: 'B', status: 'task' });
-        const completed = core.updateTask(task.id, { status: 'cancelled' });
-        expect(completed?.completedAt).toBeTruthy();
-        const completedAt = completed?.completedAt;
-        const archived = core.archiveTask(task.id, true, 'No longer needed');
-        expect(archived?.completedAt).toBe(completedAt);
-        core.close();
-    });
-    it('sets completedAt when archiving an active task', () => {
-        const core = createCore();
-        const task = core.createTask({ title: 'C', status: 'in-progress' });
-        const archived = core.archiveTask(task.id, false);
-        expect(archived?.completedAt).toBeTruthy();
-        core.close();
-    });
-});

package/dist/core/CreatedBy.test.d.ts

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

package/dist/core/CreatedBy.test.js

@@ -1,188 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, it, expect } from 'vitest';
-import { TaskforceCore } from './Taskforce';
-function createProjectRoot(prefix = 'taskforce-created-by-') {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'created-by-test' }), 'utf-8');
-    return root;
-}
-const createdRoots = [];
-afterEach(() => {
-    while (createdRoots.length > 0) {
-        const root = createdRoots.pop();
-        if (root && fs.existsSync(root)) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    }
-});
-describe('TaskforceCore - createdBy Field', () => {
-    it('does not persist new generic AI createdBy values on creation', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'AI Task',
-            createdBy: 'AI Agent'
-        });
-        expect(task.createdBy).toBeUndefined();
-    });
-    it('preserves legacy generic AI createdBy values when hydrating stored tasks', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({ title: 'Legacy AI task' });
-        core.db.prepare(`
-            UPDATE tasks
-            SET created_by = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
-        `).run('agent', 'default', 'default', task.id);
-        const hydrated = core.getTask(task.id);
-        expect(hydrated?.createdBy).toBe('agent');
-        expect(hydrated?.createdByActor).toEqual(expect.objectContaining({
-            id: 'agent',
-            kind: 'ai',
-            isNamed: false
-        }));
-    });
-    it('defaults createdBy to undefined if not provided', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({ title: 'User Task' });
-        expect(task.createdBy).toBeUndefined();
-    });
-    it('treats legacy [User] title hints as unassigned when assignee is missing', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: '[User] Configure backups',
-            createdBy: 'AI Agent'
-        });
-        expect(task.assignee).toBe('unassigned');
-    });
-    it('keeps legacy owner hints unassigned for compatibility', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'Configure alerts',
-            description: 'Owner: User',
-            assignee: 'unassigned',
-            createdBy: 'AI Agent'
-        });
-        expect(task.assignee).toBe('unassigned');
-    });
-    it('defaults AI-authored tasks to unassigned when no explicit assignee is provided', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'AI-created task',
-            createdBy: 'AI Agent'
-        });
-        expect(task.assignee).toBe('unassigned');
-    });
-    it('repairs unknown member assignees to unassigned', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'Assign to workspace member',
-            assignee: 'member-123',
-            createdBy: 'AI Agent'
-        });
-        expect(task.assignee).toBe('unassigned');
-    });
-    it('normalizes legacy agent assignees to unassigned on create', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'Legacy AI-owned task',
-            assignee: 'agent',
-            createdBy: 'AI Agent'
-        });
-        expect(task.assignee).toBe('unassigned');
-    });
-    it('preserves registered AI profile assignees', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const { profile } = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex'
-        });
-        const task = core.createTask({
-            title: 'Assign to Codex',
-            assignee: profile.id
-        }, { workspaceId: 'workspace-1' });
-        expect(task.assignee).toBe(profile.id);
-    });
-    it('self-repairs stored assignees that no longer exist back to unassigned', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const { profile } = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex'
-        });
-        const task = core.createTask({
-            title: 'Task with stale assignee',
-            assignee: profile.id
-        }, { workspaceId: 'workspace-1' });
-        core.db.prepare(`
-            UPDATE tasks
-            SET assignee = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
-        `).run('ghost-assignee', 'default', 'workspace-1', task.id);
-        const repaired = core.getTask(task.id, 'workspace-1');
-        expect(repaired?.assignee).toBe('unassigned');
-        const persisted = core.db.prepare(`
-            SELECT assignee
-            FROM tasks
-            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
-        `).get('default', 'workspace-1', task.id);
-        expect(persisted?.assignee).toBe('unassigned');
-    });
-    it('normalizes escaped newlines for AI-authored task descriptions on create', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'AI task with escaped description',
-            description: 'Phase 1\\n\\nPhase 2',
-            createdBy: 'AI Agent'
-        });
-        expect(task.description).toBe('Phase 1\n\nPhase 2');
-    });
-    it('preserves literal escaped newlines for manual task descriptions on create', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'Manual task with literal backslashes',
-            description: 'Keep literal \\n\\n text'
-        });
-        expect(task.description).toBe('Keep literal \\n\\n text');
-    });
-    it('normalizes escaped newlines when updating an AI-authored task description', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'AI task to update',
-            createdBy: 'AI Agent'
-        });
-        const updated = core.updateTask(task.id, {
-            description: 'Line 1\\r\\n\\r\\nLine 2',
-            createdBy: 'AI Agent'
-        });
-        expect(updated?.description).toBe('Line 1\n\nLine 2');
-        expect(updated?.createdBy).toBeUndefined();
-    });
-});

package/dist/core/DeletedTaskTrash.test.d.ts

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

package/dist/core/DeletedTaskTrash.test.js

@@ -1,104 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { TaskforceCore } from './Taskforce';
-function makeCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-deleted-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-describe('TaskforceCore deleted task lifecycle', () => {
-    it('moves deleted tasks into deleted-task history with actor, source, and snapshot data', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({
-                title: 'Trash me',
-                description: 'Forensics matter',
-                createdBy: 'user'
-            }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            const deleted = core.softDeleteTask(task.id, 'workspace-a', { actorRef: 'user', source: 'ui' });
-            expect(deleted).toEqual(expect.objectContaining({
-                taskId: task.id,
-                source: 'ui',
-                actor: 'user',
-                actorType: 'human',
-                taskSnapshot: expect.objectContaining({
-                    id: task.id,
-                    title: 'Trash me',
-                    description: 'Forensics matter'
-                })
-            }));
-            expect(core.getTask(task.id, 'workspace-a')).toBeNull();
-            expect(core.listDeletedTasks('workspace-a').deleted).toHaveLength(1);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('restores a deleted task back into active tasks and removes it from deleted-task history', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({
-                title: 'Bring me back',
-                comments: [{ id: 'comment-1', author: 'user', text: 'Keep this note', timestamp: '2026-03-22T10:00:00.000Z' }],
-                createdBy: 'user'
-            }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            const deleted = core.softDeleteTask(task.id, 'workspace-a', { actorRef: 'user', source: 'ui' });
-            const restored = core.restoreDeletedTask(deleted.id, 'workspace-a', { actorRef: 'user' });
-            expect(restored).toEqual(expect.objectContaining({
-                id: task.id,
-                title: 'Bring me back',
-                comments: expect.arrayContaining([
-                    expect.objectContaining({ text: 'Keep this note' })
-                ])
-            }));
-            expect(core.listDeletedTasks('workspace-a').deleted).toHaveLength(0);
-            expect(core.getTask(task.id, 'workspace-a')).not.toBeNull();
-            expect(core.listTaskEvents(task.id, 'workspace-a').map((event) => event.action)).toContain('task-restored');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('purges deleted task records older than the retention window', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const staleTask = core.createTask({
-                title: 'Old deleted task',
-                createdBy: 'user'
-            }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            const freshTask = core.createTask({
-                title: 'Fresh deleted task',
-                createdBy: 'user'
-            }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            const staleDeleted = core.softDeleteTask(staleTask.id, 'workspace-a', { actorRef: 'user', source: 'ui' });
-            const freshDeleted = core.softDeleteTask(freshTask.id, 'workspace-a', { actorRef: 'user', source: 'ui' });
-            const staleDeletedAt = new Date(Date.now() - (91 * 24 * 60 * 60 * 1000)).toISOString();
-            core.db.prepare(`
-                UPDATE deleted_tasks
-                SET deleted_at = ?
-                WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?
-            `).run(staleDeletedAt, core.getTenantId(), 'workspace-a', staleTask.id);
-            const listed = core.listDeletedTasks('workspace-a').deleted;
-            expect(listed).toHaveLength(1);
-            expect(listed[0]?.taskId).toBe(freshTask.id);
-            expect(core.getDeletedTask(staleDeleted.id, 'workspace-a')).toBeNull();
-            expect(core.getDeletedTask(freshDeleted.id, 'workspace-a')).toEqual(expect.objectContaining({
-                taskId: freshTask.id
-            }));
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

package/dist/core/EntitlementsPolicy.test.d.ts

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