@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/core/WorkspacePlanMode.test.js

@@ -1,383 +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 makeProjectRoot() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-plan-mode-'));
-}
-function openCore(projectRoot) {
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    const db = core.db;
-    const now = new Date().toISOString();
-    const addFreeMapping = (planVersionId) => {
-        db.prepare(`
-            INSERT OR IGNORE INTO billing_price_mappings (
-                tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('default', planVersionId, 'month', `free:${planVersionId}:month`, 'free', 1, 0, null, now, now);
-    };
-    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free' });
-    addFreeMapping('free-v1');
-    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
-    core.updatePlanVersion({
-        planId: 'free',
-        versionNumber: 1,
-        seatLimit: 1
-    });
-    core.updatePlanVersionFeatures({
-        planVersionId: 'free-v1',
-        features: [
-            { featureKey: 'workspace.workspaces', access: 'enabled' }
-        ]
-    });
-    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5' });
-    addFreeMapping('team-5-v1');
-    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
-    core.updatePlanVersion({
-        planId: 'team-5',
-        versionNumber: 1,
-        seatLimit: 5
-    });
-    core.updatePlanVersionFeatures({
-        planVersionId: 'team-5-v1',
-        features: [
-            { featureKey: 'collaboration.invites', access: 'enabled' },
-            { featureKey: 'collaboration.team_management', access: 'enabled' }
-        ]
-    });
-    return core;
-}
-describe('TaskforceCore account-level plan mode and invite revoke', () => {
-    it('derives workspace plan mode from owner account plan across all owned workspaces', () => {
-        const projectRoot = makeProjectRoot();
-        const initial = openCore(projectRoot);
-        try {
-            const now = new Date().toISOString();
-            const db = initial.db;
-            db.prepare(`
-                INSERT INTO workspaces (id, tenant_id, slug, name, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?)
-            `).run('workspace-single', 'default', 'workspace-single', 'Single', now, now);
-            db.prepare(`
-                INSERT INTO workspaces (id, tenant_id, slug, name, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?)
-            `).run('workspace-team', 'default', 'workspace-team', 'Team', now, now);
-            db.prepare(`
-                INSERT INTO workspaces (id, tenant_id, slug, name, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?)
-            `).run('workspace-u1-second', 'default', 'workspace-u1-second', 'Second U1 Workspace', now, now);
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('u1', 'default', 'u1@example.com', 'U1', now, now);
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('u2', 'default', 'u2@example.com', 'U2', now, now);
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('u3', 'default', 'u3@example.com', 'U3', now, now);
-            db.prepare(`
-                INSERT INTO workspace_memberships (id, tenant_id, workspace_id, user_id, role, status, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `).run('m1', 'default', 'workspace-single', 'u1', 'owner', 'active', now, now);
-            db.prepare(`
-                INSERT INTO workspace_memberships (id, tenant_id, workspace_id, user_id, role, status, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `).run('m2', 'default', 'workspace-team', 'u2', 'owner', 'active', now, now);
-            db.prepare(`
-                INSERT INTO workspace_memberships (id, tenant_id, workspace_id, user_id, role, status, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `).run('m3', 'default', 'workspace-team', 'u3', 'member', 'active', now, now);
-            db.prepare(`
-                INSERT INTO workspace_memberships (id, tenant_id, workspace_id, user_id, role, status, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `).run('m4', 'default', 'workspace-u1-second', 'u1', 'owner', 'active', now, now);
-            initial.setUserAccountPlanMode('u2', 'team');
-        }
-        finally {
-            initial.close();
-        }
-        const reopened = openCore(projectRoot);
-        try {
-            expect(reopened.getWorkspacePlanMode('workspace-single')).toBe('personal');
-            expect(reopened.getWorkspacePlanMode('workspace-team')).toBe('team');
-            expect(reopened.getWorkspacePlanMode('workspace-u1-second')).toBe('personal');
-            reopened.setWorkspacePlanMode('workspace-single', 'team');
-            expect(reopened.getWorkspacePlanMode('workspace-single')).toBe('team');
-            expect(reopened.getWorkspacePlanMode('workspace-u1-second')).toBe('team');
-        }
-        finally {
-            reopened.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('marks invite token as revoked and inspect reflects revoked state', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-invite', name: 'Invite Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'user-invite',
-                workspaceId: 'workspace-invite',
-                role: 'member',
-                email: 'invite@example.com'
-            });
-            const invite = core.requestInviteAcceptance({ userId: 'user-invite', workspaceId: 'workspace-invite' });
-            expect(typeof invite.token).toBe('string');
-            const revoke = core.revokeInviteAcceptanceForUser('user-invite');
-            expect(revoke.revoked).toBeGreaterThan(0);
-            const inspected = core.inspectInviteAcceptance(String(invite.token));
-            expect(inspected.state).toBe('revoked');
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('classifies invited placeholder users as new users and registered users as existing users', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-invite', name: 'Invite Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'user-new',
-                workspaceId: 'workspace-invite',
-                role: 'member',
-                email: 'new@example.com'
-            });
-            core.ensurePasswordUser({
-                email: 'existing@example.com',
-                password: 'HarborLanternOrbit!2026',
-                workspaceId: 'workspace-invite',
-                role: 'member'
-            });
-            const inviteNew = core.requestInviteAcceptance({ userId: 'user-new', workspaceId: 'workspace-invite' });
-            const inspectNew = core.inspectInviteAcceptance(String(inviteNew.token));
-            expect(inspectNew.inviteeKind).toBe('new_user');
-            expect(inspectNew.passwordRequired).toBe(true);
-            const existingUserId = core.resolveUserIdentity('user-new')?.userId;
-            expect(existingUserId).toBe('user-new');
-            const existingLookup = core.db.prepare(`
-                SELECT id FROM users WHERE tenant_id = ? AND email = ? LIMIT 1
-            `).get('default', 'existing@example.com');
-            const inviteExisting = core.requestInviteAcceptance({ userId: String(existingLookup?.id || ''), workspaceId: 'workspace-invite' });
-            const inspectExisting = core.inspectInviteAcceptance(String(inviteExisting.token));
-            expect(inspectExisting.inviteeKind).toBe('existing_user');
-            expect(inspectExisting.passwordRequired).toBe(false);
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('joins invite for existing authenticated users without changing their password hash', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-invite', name: 'Invite Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-user',
-                workspaceId: 'workspace-invite',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.setUserAccountPlanMode('owner-user', 'team');
-            const existing = core.ensurePasswordUser({
-                email: 'existing@example.com',
-                password: 'HarborLanternOrbit!2026',
-                workspaceId: 'workspace-invite',
-                role: 'member'
-            });
-            core.setWorkspaceUserDisabled(existing.userId, 'workspace-invite', true);
-            const db = core.db;
-            db.prepare(`
-                UPDATE workspace_memberships
-                SET status = 'invited'
-                WHERE tenant_id = ? AND user_id = ? AND workspace_id = ?
-            `).run('default', existing.userId, 'workspace-invite');
-            const before = db.prepare(`
-                SELECT password_hash FROM user_auth_identities
-                WHERE tenant_id = ? AND user_id = ? AND provider = 'password' LIMIT 1
-            `).get('default', existing.userId);
-            const invite = core.requestInviteAcceptance({ userId: existing.userId, workspaceId: 'workspace-invite' });
-            const accepted = core.joinInviteWithAuthenticatedUser({
-                token: String(invite.token),
-                userId: existing.userId
-            });
-            const after = db.prepare(`
-                SELECT password_hash FROM user_auth_identities
-                WHERE tenant_id = ? AND user_id = ? AND provider = 'password' LIMIT 1
-            `).get('default', existing.userId);
-            const membership = db.prepare(`
-                SELECT status FROM workspace_memberships WHERE tenant_id = ? AND user_id = ? AND workspace_id = ? LIMIT 1
-            `).get('default', existing.userId, 'workspace-invite');
-            expect(accepted.workspaceId).toBe('workspace-invite');
-            expect(before?.password_hash).toBeTruthy();
-            expect(after?.password_hash).toBe(before?.password_hash);
-            expect(membership?.status).toBe('active');
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('grants the default onboarding entitlement to newly accepted invited accounts', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.updateGlobalSettings({
-                billing: {
-                    onboardingPolicy: {
-                        mode: 'auto_grant_free',
-                        planId: 'free'
-                    }
-                }
-            });
-            core.createWorkspace({ workspaceId: 'workspace-invite', name: 'Invite Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-user',
-                workspaceId: 'workspace-invite',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.setUserAccountPlanMode('owner-user', 'team');
-            core.ensureBootstrapUserAccess({
-                userId: 'invited-user',
-                workspaceId: 'workspace-invite',
-                role: 'member',
-                email: 'invited@example.com'
-            });
-            core.setWorkspaceUserDisabled('invited-user', 'workspace-invite', true);
-            const db = core.db;
-            db.prepare(`
-                UPDATE workspace_memberships
-                SET status = 'invited'
-                WHERE tenant_id = ? AND user_id = ? AND workspace_id = ?
-            `).run('default', 'invited-user', 'workspace-invite');
-            const invite = core.requestInviteAcceptance({ userId: 'invited-user', workspaceId: 'workspace-invite' });
-            const accepted = core.acceptInviteWithToken({
-                token: String(invite.token),
-                password: 'LanternHarborOrbit!2026'
-            });
-            expect(accepted.workspaceId).toBe('workspace-invite');
-            expect(core.hasAccountEntitlement('invited-user')).toBe(true);
-            expect(core.getAccountEntitlement('invited-user')).toEqual(expect.objectContaining({
-                planVersionId: 'free-v1',
-                state: 'active'
-            }));
-            expect(core.getAccountAccessStatus('invited-user')).toEqual(expect.objectContaining({
-                gate: 'ok',
-                canAccessApp: true
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('grants the free personal entitlement to newly accepted invited accounts even without explicit self-serve onboarding policy', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-invite', name: 'Invite Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-user',
-                workspaceId: 'workspace-invite',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.setUserAccountPlanMode('owner-user', 'team');
-            core.ensureBootstrapUserAccess({
-                userId: 'invited-user',
-                workspaceId: 'workspace-invite',
-                role: 'member',
-                email: 'invited-no-policy@example.com'
-            });
-            core.setWorkspaceUserDisabled('invited-user', 'workspace-invite', true);
-            const db = core.db;
-            db.prepare(`
-                UPDATE workspace_memberships
-                SET status = 'invited'
-                WHERE tenant_id = ? AND user_id = ? AND workspace_id = ?
-            `).run('default', 'invited-user', 'workspace-invite');
-            const invite = core.requestInviteAcceptance({ userId: 'invited-user', workspaceId: 'workspace-invite' });
-            const accepted = core.acceptInviteWithToken({
-                token: String(invite.token),
-                password: 'LanternHarborOrbit!2026'
-            });
-            expect(accepted.workspaceId).toBe('workspace-invite');
-            expect(core.hasAccountEntitlement('invited-user')).toBe(true);
-            expect(core.getAccountEntitlement('invited-user')).toEqual(expect.objectContaining({
-                planVersionId: 'free-v1',
-                state: 'active'
-            }));
-            expect(core.getAccountAccessStatus('invited-user')).toEqual(expect.objectContaining({
-                gate: 'ok',
-                canAccessApp: true
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('reactivates blocked placeholder entitlements when a new invited user accepts a reused seat', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-invite', name: 'Invite Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-user',
-                workspaceId: 'workspace-invite',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.setUserAccountPlanMode('owner-user', 'team');
-            core.ensureBootstrapUserAccess({
-                userId: 'invited-user',
-                workspaceId: 'workspace-invite',
-                role: 'member',
-                email: 'invited@example.com'
-            });
-            core.setWorkspaceUserDisabled('invited-user', 'workspace-invite', true);
-            const db = core.db;
-            db.prepare(`
-                UPDATE workspace_memberships
-                SET status = 'invited'
-                WHERE tenant_id = ? AND user_id = ? AND workspace_id = ?
-            `).run('default', 'invited-user', 'workspace-invite');
-            core.updateAccountEntitlement({
-                accountId: 'invited-user',
-                planVersionId: 'free-v1',
-                entitlementState: 'canceled',
-                actorUserId: 'system-admin',
-                actorRole: 'system_admin',
-                reason: 'invite-reaccept-regression'
-            });
-            const invite = core.requestInviteAcceptance({ userId: 'invited-user', workspaceId: 'workspace-invite' });
-            const accepted = core.acceptInviteWithToken({
-                token: String(invite.token),
-                password: 'LanternHarborOrbit!2026'
-            });
-            expect(accepted.workspaceId).toBe('workspace-invite');
-            expect(core.getAccountEntitlement('invited-user')).toEqual(expect.objectContaining({
-                planVersionId: 'free-v1',
-                state: 'active'
-            }));
-            expect(core.getAccountAccessStatus('invited-user')).toEqual(expect.objectContaining({
-                gate: 'ok',
-                canAccessApp: true
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-});

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

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

package/dist/core/WorkspaceSyncSettings.test.js

@@ -1,65 +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 createdRoots = [];
-const originalHome = process.env.HOME;
-function createProjectRoot(prefix = 'taskforce-workspace-sync-settings-') {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    process.env.HOME = root;
-    createdRoots.push(root);
-    return root;
-}
-afterEach(() => {
-    process.env.HOME = originalHome;
-    while (createdRoots.length > 0) {
-        const root = createdRoots.pop();
-        if (root && fs.existsSync(root)) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    }
-});
-describe('TaskforceCore workspace shareable sync settings', () => {
-    it('returns an empty snapshot when no workspace-shareable settings are allowlisted', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        expect(core.getWorkspaceShareableSyncSettings('workspace-1')).toEqual({
-            settings: {},
-            updatedAt: null
-        });
-    });
-    it('drops disallowed workspace_settings rows from the sync snapshot', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const db = core.getDatabaseAdapter();
-        const now = new Date().toISOString();
-        db.prepare(`
-            INSERT INTO workspace_settings (tenant_id, workspace_id, settings_key, payload, updated_at)
-            VALUES (?, ?, ?, ?, ?)
-        `).run('default', 'workspace-1', 'dangerous-admin-setting', JSON.stringify({ enabled: true }), now);
-        expect(core.getWorkspaceShareableSyncSettings('workspace-1')).toEqual({
-            settings: {},
-            updatedAt: null
-        });
-    });
-    it('ignores attempted writes for disallowed workspace-shareable sync settings', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const result = core.upsertWorkspaceShareableSyncSettings('workspace-1', {
-            dangerousAdminSetting: { enabled: true }
-        }, '2026-03-17T12:00:00.000Z');
-        expect(result).toEqual({
-            settings: {},
-            updatedAt: null,
-            applied: false
-        });
-        const db = core.getDatabaseAdapter();
-        const rows = db.prepare(`
-            SELECT settings_key
-            FROM workspace_settings
-            WHERE tenant_id = ? AND workspace_id = ?
-        `).all('default', 'workspace-1');
-        expect(rows).toEqual([]);
-    });
-});

package/dist/core/__tests__/TaskAttachmentsCanonical.test.d.ts

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

package/dist/core/__tests__/TaskAttachmentsCanonical.test.js

@@ -1,212 +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 createdRoots = [];
-const originalHome = process.env.HOME;
-function createProjectRoot(prefix = 'taskforce-canonical-attachments-') {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    process.env.HOME = root;
-    createdRoots.push(root);
-    return root;
-}
-afterEach(() => {
-    process.env.HOME = originalHome;
-    while (createdRoots.length > 0) {
-        const root = createdRoots.pop();
-        if (root && fs.existsSync(root)) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    }
-});
-describe('TaskforceCore canonical task attachments', () => {
-    it('renders canonical asset links as task attachments', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const created = core.createTask({
-            title: 'Attachment task'
-        }, { workspaceId: 'default' });
-        const db = core.getDatabaseAdapter();
-        const now = new Date().toISOString();
-        const storageKey = 'workspaces/default/assets/documents/asset-doc-1-implementation-plan.md';
-        db.prepare(`
-            INSERT INTO workspace_assets (
-                asset_id, tenant_id, workspace_id, kind, logical_name, original_filename, mime_type,
-                storage_provider, storage_key, content_sha256, size_bytes, document_id, version,
-                is_latest, scan_status, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('asset-doc-1', 'default', 'default', 'document', 'Implementation Plan', 'implementation-plan.md', 'text/markdown', 'r2', storageKey, 'sha-doc-1', 120, 'doc-1', 1, 1, 'clean', now, now);
-        db.prepare(`
-            INSERT INTO workspace_asset_links (
-                tenant_id, workspace_id, asset_id, task_id, role, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?)
-        `).run('default', 'default', 'asset-doc-1', created.id, 'attachment', now, now);
-        const tasks = core.listTasks('default').tasks;
-        const task = tasks.find((entry) => entry.id === created.id);
-        expect(task?.attachments).toEqual([
-            expect.objectContaining({
-                path: `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
-                fsPath: storageKey,
-                caption: 'Implementation Plan'
-            })
-        ]);
-    });
-    it('writes canonical task attachment links when attachments are updated from payload data', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const created = core.createTask({
-            title: 'Attachment write task'
-        }, { workspaceId: 'default' });
-        const db = core.getDatabaseAdapter();
-        const now = new Date().toISOString();
-        const storageKey = 'workspaces/default/assets/files/asset-file-1-brief.pdf';
-        db.prepare(`
-            INSERT INTO workspace_assets (
-                asset_id, tenant_id, workspace_id, kind, original_filename, mime_type,
-                storage_provider, storage_key, content_sha256, size_bytes, is_latest,
-                scan_status, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('asset-file-1', 'default', 'default', 'file', 'brief.pdf', 'application/pdf', 'r2', storageKey, 'sha-file-1', 88, 1, 'clean', now, now);
-        core.updateTask(created.id, {
-            attachments: [{
-                    path: `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
-                    fsPath: storageKey,
-                    caption: 'Brief',
-                    timestamp: now
-                }]
-        }, 'default');
-        const rows = db.prepare(`
-            SELECT asset_id, task_id, role, deleted_at
-            FROM workspace_asset_links
-            WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?
-        `).all('default', 'default', created.id);
-        expect(rows).toEqual([
-            expect.objectContaining({
-                asset_id: 'asset-file-1',
-                task_id: created.id,
-                role: 'attachment',
-                deleted_at: null
-            })
-        ]);
-    });
-    it('renders canonical image attachments through the unified context route', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const created = core.createTask({
-            title: 'Image attachment task'
-        }, { workspaceId: 'default' });
-        const db = core.getDatabaseAdapter();
-        const now = new Date().toISOString();
-        const storageKey = 'workspaces/default/assets/images/asset-image-1-proof.png';
-        db.prepare(`
-            INSERT INTO workspace_assets (
-                asset_id, tenant_id, workspace_id, kind, logical_name, original_filename, mime_type,
-                storage_provider, storage_key, content_sha256, size_bytes, is_latest, scan_status, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('asset-image-1', 'default', 'default', 'image', 'Proof', 'proof.png', 'image/png', 'local', storageKey, 'sha-image-1', 42, 1, 'clean', now, now);
-        db.prepare(`
-            INSERT INTO workspace_asset_links (
-                tenant_id, workspace_id, asset_id, task_id, role, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?)
-        `).run('default', 'default', 'asset-image-1', created.id, 'image', now, now);
-        const imagePath = path.join(projectRoot, '.taskforce', storageKey);
-        fs.mkdirSync(path.dirname(imagePath), { recursive: true });
-        fs.writeFileSync(imagePath, 'png');
-        const task = core.getTask(created.id, 'default');
-        expect(task?.attachments).toEqual([
-            expect.objectContaining({
-                path: `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
-                fsPath: storageKey,
-                caption: 'Proof'
-            })
-        ]);
-    });
-    it('does not render broken local canonical attachments when the file is missing', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const created = core.createTask({
-            title: 'Broken attachment task'
-        }, { workspaceId: 'default' });
-        const db = core.getDatabaseAdapter();
-        const now = new Date().toISOString();
-        const storageKey = 'workspaces/default/assets/images/asset-image-2-broken.png';
-        db.prepare(`
-            INSERT INTO workspace_assets (
-                asset_id, tenant_id, workspace_id, kind, logical_name, original_filename, mime_type,
-                storage_provider, storage_key, content_sha256, size_bytes, is_latest, scan_status, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('asset-image-2', 'default', 'default', 'image', 'Broken Proof', 'broken.png', 'image/png', 'local', storageKey, 'sha-image-2', 42, 1, 'clean', now, now);
-        db.prepare(`
-            INSERT INTO workspace_asset_links (
-                tenant_id, workspace_id, asset_id, task_id, role, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?)
-        `).run('default', 'default', 'asset-image-2', created.id, 'image', now, now);
-        const task = core.getTask(created.id, 'default');
-        expect(task?.attachments).toEqual([]);
-    });
-    it('persists linked local files with a stable display name and context-link path', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const created = core.createTask({
-            title: 'Linked file task'
-        }, { workspaceId: 'default' });
-        const linkedPath = 'docs/architecture/decision-record.md';
-        const now = new Date().toISOString();
-        core.updateTask(created.id, {
-            attachments: [{
-                    path: `/api/taskforce/context-link?path=${encodeURIComponent(linkedPath)}`,
-                    fsPath: linkedPath,
-                    caption: 'Architecture Decision Record',
-                    timestamp: now
-                }]
-        }, 'default');
-        const db = core.getDatabaseAdapter();
-        const assetRow = db.prepare(`
-            SELECT asset_id, storage_provider, storage_key, logical_name, original_filename
-            FROM workspace_assets
-            WHERE tenant_id = ? AND workspace_id = ? AND storage_key = ?
-            LIMIT 1
-        `).get('default', 'default', linkedPath);
-        expect(assetRow).toEqual(expect.objectContaining({
-            storage_provider: 'external',
-            storage_key: linkedPath,
-            logical_name: 'Architecture Decision Record',
-            original_filename: 'Architecture Decision Record'
-        }));
-        const linkRow = db.prepare(`
-            SELECT display_name, role, deleted_at
-            FROM workspace_asset_links
-            WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?
-            LIMIT 1
-        `).get('default', 'default', created.id);
-        expect(linkRow).toEqual(expect.objectContaining({
-            display_name: 'Architecture Decision Record',
-            role: 'attachment',
-            deleted_at: null
-        }));
-        const task = core.getTask(created.id, 'default');
-        expect(task?.attachments).toEqual([
-            expect.objectContaining({
-                path: `/api/taskforce/context-link?path=${encodeURIComponent(linkedPath)}`,
-                fsPath: linkedPath,
-                caption: 'Architecture Decision Record',
-                displayName: 'Architecture Decision Record',
-                originalFilename: 'Architecture Decision Record'
-            })
-        ]);
-    });
-    it('does not read legacy task-folder attachments when canonical metadata is absent', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const created = core.createTask({
-            title: 'Filesystem attachment fallback'
-        }, { workspaceId: 'default' });
-        const taskDir = path.join(projectRoot, '.taskforce', 'task-data', created.id, 'attachments');
-        fs.mkdirSync(taskDir, { recursive: true });
-        const filePath = path.join(taskDir, 'notes.txt');
-        fs.writeFileSync(filePath, 'hello');
-        const task = core.getTask(created.id, 'default');
-        expect(task?.attachments).toEqual([]);
-    });
-});

package/dist/documentReviews/DocumentReviewSessionStore.test.d.ts

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