@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/core/UserProfileAvatarDrafts.test.js

@@ -1,138 +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-user-avatar-'));
-}
-function seedPlans(core) {
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'active' });
-    core.updatePlanVersion({
-        planId: 'starter',
-        versionNumber: 1,
-        seatLimit: 1
-    });
-    const db = core.db;
-    const now = new Date().toISOString();
-    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(core.getTenantId(), 'starter-v1', 'month', 'free:starter-v1:month', 'free', 1, 0, null, now, now);
-    core.updateGlobalSettings({
-        billing: {
-            onboardingPolicy: {
-                mode: 'auto_grant_free',
-                planId: 'starter'
-            }
-        }
-    });
-}
-function openCore(projectRoot) {
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    seedPlans(core);
-    return core;
-}
-describe('TaskforceCore user profile avatar drafts', () => {
-    it('persists avatarUrl on profile updates and exposes it in resolved identity', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            const created = core.registerPasswordUser({
-                email: 'avatar-user@example.com',
-                password: 'ValidPassphrase123!'
-            });
-            const updated = core.updateUserProfile(created.userId, {
-                displayName: 'Avatar User',
-                avatarUrl: `/api/taskforce/context/${encodeURIComponent(`users/${created.userId}/profile/avatar/headshot.png`)}`
-            });
-            expect(updated).toMatchObject({
-                userId: created.userId,
-                displayName: 'Avatar User',
-                avatarUrl: `/api/taskforce/context/${encodeURIComponent(`users/${created.userId}/profile/avatar/headshot.png`)}`
-            });
-            expect(core.resolveUserIdentity(created.userId)?.avatarUrl).toBe(`/api/taskforce/context/${encodeURIComponent(`users/${created.userId}/profile/avatar/headshot.png`)}`);
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('exposes cloud-owned user avatarUrl on live workspace member records', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            const created = core.registerPasswordUser({
-                email: 'member-avatar@example.com',
-                password: 'ValidPassphrase123!',
-                workspaceId: 'workspace-1'
-            });
-            const avatarUrl = `/api/taskforce/context/${encodeURIComponent(`users/${created.userId}/profile/avatar/headshot.webp`)}`;
-            core.updateUserProfile(created.userId, {
-                displayName: 'Member Avatar',
-                avatarUrl
-            });
-            const members = core.listWorkspaceUsers('workspace-1');
-            expect(members.find((member) => member.userId === created.userId)).toEqual(expect.objectContaining({
-                userId: created.userId,
-                displayName: 'Member Avatar',
-                avatarUrl
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('tracks, finalizes, discards, and cleans up stale avatar upload drafts', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            const created = core.registerPasswordUser({
-                email: 'draft-user@example.com',
-                password: 'ValidPassphrase123!'
-            });
-            const draft = core.createUserAvatarUploadDraft({
-                userId: created.userId,
-                draftId: 'avatar-draft-1',
-                storageKey: `users/${created.userId}/profile/avatar/avatar-draft-1-headshot.png`,
-                mimeType: 'image/png',
-                originalFilename: 'headshot.png',
-                sizeBytes: 1024,
-                storageProvider: 'r2'
-            });
-            expect(draft.finalizedAt).toBeNull();
-            expect(core.markUserAvatarUploadDraftFinalized(created.userId, draft.draftId)?.finalizedAt).toEqual(expect.any(String));
-            expect(core.markUserAvatarUploadDraftConsumed(created.userId, draft.draftId)?.consumedAt).toEqual(expect.any(String));
-            expect(core.discardUserAvatarUploadDraft(created.userId, draft.draftId)?.discardedAt).toEqual(expect.any(String));
-            core.createUserAvatarUploadDraft({
-                userId: created.userId,
-                draftId: 'avatar-draft-stale',
-                storageKey: `users/${created.userId}/profile/avatar/avatar-draft-stale-headshot.png`,
-                mimeType: 'image/png',
-                originalFilename: 'stale.png',
-                sizeBytes: 512,
-                storageProvider: 'r2'
-            });
-            const db = core.db;
-            db.prepare(`
-                UPDATE user_avatar_upload_drafts
-                SET created_at = ?, updated_at = ?
-                WHERE tenant_id = ? AND user_id = ? AND draft_id = ?
-            `).run('2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z', core.getTenantId(), created.userId, 'avatar-draft-stale');
-            const stale = core.cleanupStaleUserAvatarUploadDrafts(created.userId, '2026-02-01T00:00:00.000Z');
-            expect(stale).toHaveLength(1);
-            expect(stale[0]?.draftId).toBe('avatar-draft-stale');
-            expect(core.getUserAvatarUploadDraft(created.userId, 'avatar-draft-stale')?.discardedAt).toEqual(expect.any(String));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-});

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

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

package/dist/core/WorkspaceDelete.test.js

@@ -1,159 +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-workspace-delete-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    const db = core.getDatabaseAdapter();
-    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: 'starter', displayName: 'Starter' });
-    addFreeMapping('starter-v1');
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'active' });
-    core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab' });
-    addFreeMapping('collab-v1');
-    core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab', status: 'active' });
-    core.updatePlanVersion({
-        planId: 'collab',
-        versionNumber: 1,
-        seatLimit: 5
-    });
-    core.updatePlanVersionFeatures({
-        planVersionId: 'collab-v1',
-        features: [
-            { featureKey: 'collaboration.team_management', access: 'enabled' }
-        ]
-    });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-function countByWorkspace(core, table, workspaceId) {
-    const row = core.getDatabaseAdapter().prepare(`
-        SELECT COUNT(*) AS count
-        FROM ${table}
-        WHERE tenant_id = ? AND workspace_id = ?
-    `).get(core.getTenantId(), workspaceId);
-    return Number(row?.count || 0);
-}
-describe('TaskforceCore deleteWorkspace', () => {
-    it('cascades deletion for workspace-scoped rows and preserves other workspaces', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const tenantId = core.getTenantId();
-            const wsDelete = 'workspace-delete';
-            const wsKeep = 'workspace-keep';
-            const now = '2026-03-03T10:00:00.000Z';
-            core.createWorkspace({ workspaceId: wsDelete, name: 'Workspace Delete' });
-            core.createWorkspace({ workspaceId: wsKeep, name: 'Workspace Keep' });
-            core.ensureBootstrapUserAccess({ userId: 'owner-del', workspaceId: wsDelete, role: 'owner', email: 'del@example.com' });
-            core.ensureBootstrapUserAccess({ userId: 'owner-keep', workspaceId: wsKeep, role: 'owner', email: 'keep@example.com' });
-            const workstream = core.createWorkstream({ title: 'Delete Workstream' }, wsDelete);
-            const parent = core.createTask({ title: 'Parent Delete', workstreamId: workstream.id }, { workspaceId: wsDelete });
-            const child = core.createTask({ title: 'Child Delete', workstreamId: workstream.id }, { workspaceId: wsDelete });
-            const sibling = core.createTask({ title: 'Sibling Delete' }, { workspaceId: wsDelete });
-            const keepTask = core.createTask({ title: 'Keep Task' }, { workspaceId: wsKeep });
-            core.addComment(parent.id, 'comment delete', 'owner-del', wsDelete);
-            core.getDatabaseAdapter().prepare(`
-                INSERT INTO auth_tokens (id, tenant_id, user_id, workspace_id, purpose, token_hash, expires_at, used_at, revoked_at, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `).run('token-delete', tenantId, 'owner-del', wsDelete, 'password_reset', 'hash-delete', '2099-01-01T00:00:00.000Z', null, null, now);
-            core.getDatabaseAdapter().prepare(`
-                INSERT INTO auth_tokens (id, tenant_id, user_id, workspace_id, purpose, token_hash, expires_at, used_at, revoked_at, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `).run('token-keep', tenantId, 'owner-keep', wsKeep, 'password_reset', 'hash-keep', '2099-01-01T00:00:00.000Z', null, null, now);
-            core.updateUiState(wsDelete, 'owner-del', { stateKey: 'workspace-sync', patch: { enabled: true } });
-            core.updateUiState(wsKeep, 'owner-keep', { stateKey: 'workspace-sync', patch: { enabled: true } });
-            core.setWorkspacePlanMode(wsDelete, 'team', 'test');
-            core.setWorkspacePlanMode(wsKeep, 'team', 'test');
-            core.addAdminAuditLog({ action: 'test-delete', actorUserId: 'owner-del', actorRole: 'owner', workspaceId: wsDelete, details: { phase: 'before' } });
-            core.addAdminAuditLog({ action: 'test-keep', actorUserId: 'owner-keep', actorRole: 'owner', workspaceId: wsKeep, details: { phase: 'before' } });
-            core.recordSyncEvent(wsDelete, { eventType: 'pull', status: 'success' });
-            core.recordSyncEvent(wsKeep, { eventType: 'pull', status: 'success' });
-            core.writePushIdempotency(wsDelete, 'delete-key', '{}');
-            core.writePushIdempotency(wsKeep, 'keep-key', '{}');
-            core.deleteTask(child.id, wsDelete);
-            core.upsertDocumentWatermark(wsDelete, `docs/workspaces/${wsDelete}/notes.md`, 'hash-delete', now);
-            core.upsertDocumentWatermark(wsKeep, `docs/workspaces/${wsKeep}/notes.md`, 'hash-keep', now);
-            core.getDatabaseAdapter().prepare(`
-                INSERT INTO task_assets (
-                    tenant_id, workspace_id, path, provider, version, content_type, size_bytes, sha256,
-                    uploaded_at, scan_engine, scan_verdict, scan_details, scan_scanned_at, quarantine_status,
-                    deleted_at, purge_after, updated_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `).run(tenantId, wsDelete, `workspaces/${wsDelete}/tasks/${parent.id}/attachments/spec.md`, 'local', 1, 'text/markdown', 10, 'sha-delete', now, 'none', 'clean', null, now, 'none', null, null, now);
-            core.getDatabaseAdapter().prepare(`
-                INSERT INTO task_assets (
-                    tenant_id, workspace_id, path, provider, version, content_type, size_bytes, sha256,
-                    uploaded_at, scan_engine, scan_verdict, scan_details, scan_scanned_at, quarantine_status,
-                    deleted_at, purge_after, updated_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `).run(tenantId, wsKeep, `workspaces/${wsKeep}/tasks/${keepTask.id}/attachments/spec.md`, 'local', 1, 'text/markdown', 10, 'sha-keep', now, 'none', 'clean', null, now, 'none', null, null, now);
-            const summary = core.deleteWorkspace({ workspaceId: wsDelete });
-            expect(summary.deletedWorkspaceId).toBe(wsDelete);
-            expect(summary.deletedTaskIds).toEqual(expect.arrayContaining([parent.id, sibling.id]));
-            expect(summary.deletedDocumentPaths).toContain(`docs/workspaces/${wsDelete}/notes.md`);
-            expect(summary.deletedAssets.some((asset) => asset.workspaceId === wsDelete)).toBe(true);
-            expect(summary.counts.workspaces).toBe(1);
-            expect(summary.counts.workspace_memberships).toBeGreaterThan(0);
-            expect(summary.counts.tasks).toBeGreaterThan(0);
-            const workspaceDeleteExists = core.getDatabaseAdapter().prepare(`
-                SELECT 1 FROM workspaces WHERE tenant_id = ? AND id = ? LIMIT 1
-            `).get(tenantId, wsDelete);
-            const workspaceKeepExists = core.getDatabaseAdapter().prepare(`
-                SELECT 1 FROM workspaces WHERE tenant_id = ? AND id = ? LIMIT 1
-            `).get(tenantId, wsKeep);
-            expect(Boolean(workspaceDeleteExists)).toBe(false);
-            expect(Boolean(workspaceKeepExists)).toBe(true);
-            const scopedTables = [
-                'tasks',
-                'comments',
-                'task_events',
-                'workspace_memberships',
-                'auth_tokens',
-                'ui_state',
-                'workspace_settings',
-                'admin_audit_logs',
-                'workspace_sync_deletes',
-                'sync_idempotency',
-                'sync_events',
-                'workspace_documents',
-                'task_assets'
-            ];
-            for (const table of scopedTables) {
-                expect(countByWorkspace(core, table, wsDelete)).toBe(0);
-            }
-            expect(countByWorkspace(core, 'tasks', wsKeep)).toBeGreaterThan(0);
-            expect(countByWorkspace(core, 'workspace_memberships', wsKeep)).toBeGreaterThan(0);
-            expect(countByWorkspace(core, 'workspace_documents', wsKeep)).toBeGreaterThan(0);
-            expect(countByWorkspace(core, 'task_assets', wsKeep)).toBeGreaterThan(0);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('rejects deleting the reserved default workspace', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            expect(() => core.deleteWorkspace({ workspaceId: 'default' })).toThrowError(/reserved/i);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

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

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

package/dist/core/WorkspacePermissions.test.js

@@ -1,270 +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-workspace-perm-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-describe('TaskforceCore workspace permission invariants', () => {
-    it('enforces member read-only via permission_mode in resolveUserAccess', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            expect(core.setWorkspaceUserPermissionMode('member-1', 'workspace-1', 'read-only')).toBe(true);
-            const access = core.resolveUserAccess('member-1', 'workspace-1', 'member');
-            expect(access?.permissionMode).toBe('read-only');
-            expect(access?.role).toBe('read-only');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('rejects permission_mode updates for owner/admin', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            expect(() => core.setWorkspaceUserPermissionMode('owner-1', 'workspace-1', 'read-only')).toThrowError(/members/i);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('prevents demoting the last workspace owner', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            expect(() => core.updateWorkspaceUserRole('owner-1', 'workspace-1', 'admin')).toThrowError(/last workspace owner/i);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('prevents disabling and removing the last workspace owner', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            expect(() => core.setWorkspaceUserDisabled('owner-1', 'workspace-1', true)).toThrowError(/last workspace owner/i);
-            expect(() => core.removeWorkspaceUser('owner-1', 'workspace-1')).toThrowError(/last workspace owner/i);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('transfers ownership and keeps one active owner', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            expect(core.transferWorkspaceOwnership({
-                workspaceId: 'workspace-1',
-                fromUserId: 'owner-1',
-                toUserId: 'member-1'
-            })).toBe(true);
-            const users = core.listWorkspaceUsers('workspace-1');
-            const newOwner = users.find((u) => u.userId === 'member-1');
-            const previousOwner = users.find((u) => u.userId === 'owner-1');
-            expect(newOwner?.role).toBe('owner');
-            expect(previousOwner?.role).toBe('admin');
-            expect(core.countWorkspaceOwners('workspace-1')).toBe(1);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('marks deactivated workspace memberships as disabled without disabling the global account', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.createWorkspace({ workspaceId: 'workspace-home', name: 'Workspace Home' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-home',
-                role: 'owner',
-                email: 'member@example.com'
-            });
-            expect(core.setWorkspaceUserDisabled('member-1', 'workspace-1', true)).toBe(true);
-            const access = core.resolveUserAccess('member-1', 'workspace-1', 'member');
-            expect(access?.disabled).toBe(true);
-            expect(access?.accountDisabled).toBe(false);
-            expect(access?.workspaceDisabled).toBe(true);
-            expect(core.resolveUserAccess('member-1', 'workspace-home', 'owner')).toEqual(expect.objectContaining({
-                role: 'owner',
-                disabled: false,
-                accountDisabled: false,
-                workspaceDisabled: false
-            }));
-            expect(core.listUserWorkspaces('member-1').map((workspace) => workspace.id)).toEqual(['workspace-home']);
-            expect(core.listWorkspaceUsers('workspace-1').find((user) => user.userId === 'member-1')).toEqual(expect.objectContaining({
-                status: 'disabled',
-                disabled: true
-            }));
-            const row = core.db.prepare(`
-                SELECT is_disabled FROM users WHERE tenant_id = ? AND id = ? LIMIT 1
-            `).get('default', 'member-1');
-            expect(Boolean(row?.is_disabled)).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('clears active task assignments when a workspace user is disabled', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            const active = core.createTask({ title: 'Assigned Active', assignee: 'member-1' }, { workspaceId: 'workspace-1' });
-            const archived = core.createTask({ title: 'Assigned Archived', assignee: 'member-1' }, { workspaceId: 'workspace-1' });
-            core.bulkArchive([archived.id], false, 'workspace-1');
-            expect(core.setWorkspaceUserDisabled('member-1', 'workspace-1', true)).toBe(true);
-            expect(core.getTask(active.id, 'workspace-1')?.assignee).toBe('unassigned');
-            expect(core.listArchive('workspace-1').archived.find((task) => task.id === archived.id)?.assignee).toBe('member-1');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('clears active task assignments when a workspace user is removed', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            const active = core.createTask({ title: 'Assigned Active', assignee: 'member-1' }, { workspaceId: 'workspace-1' });
-            expect(core.removeWorkspaceUser('member-1', 'workspace-1')).toBe(true);
-            expect(core.getTask(active.id, 'workspace-1')?.assignee).toBe('unassigned');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('preserves existing workspace members when sync receives a partial member snapshot', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member1@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-2',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member2@example.com'
-            });
-            core.replaceWorkspaceUsersForSync({
-                workspaceId: 'workspace-1',
-                users: [
-                    {
-                        userId: 'owner-1',
-                        email: 'owner@example.com',
-                        displayName: 'Owner One',
-                        role: 'owner',
-                        permissionMode: 'read-write',
-                        betaAccess: true,
-                        status: 'active',
-                        disabled: false
-                    }
-                ]
-            });
-            const users = core.listWorkspaceUsers('workspace-1');
-            expect(users.map((user) => user.userId)).toEqual(expect.arrayContaining(['owner-1', 'member-1', 'member-2']));
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

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

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