@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/core/EntitlementsPolicy.test.js

@@ -1,280 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { TaskforceCore, TaskforceRuleError } from './Taskforce';
-import { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
-function makeProjectRoot() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-entitlements-'));
-}
-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.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5' });
-    addFreeMapping('team-5-v1');
-    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
-    core.createPlanVersion({
-        planId: 'team-5',
-        versionNumber: 2,
-        isDefault: true,
-        seatLimit: 5
-    });
-    core.updatePlanVersionFeatures({
-        planVersionId: 'team-5-v2',
-        features: [
-            { featureKey: 'collaboration.invites', access: 'enabled' },
-            { featureKey: 'collaboration.team_management', access: 'enabled' },
-            { featureKey: 'workspace.workspaces', access: 'enabled' }
-        ]
-    });
-    return core;
-}
-describe('Taskforce entitlements policy engine', () => {
-    it('counts active + invited + disabled seats and removal frees a seat', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-seat', name: 'Seat Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-seat',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.setUserAccountPlanMode('owner-u1', 'team');
-            core.ensureBootstrapUserAccess({
-                userId: 'member-u2',
-                workspaceId: 'workspace-seat',
-                role: 'member',
-                email: 'member2@example.com'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-u3',
-                workspaceId: 'workspace-seat',
-                role: 'member',
-                email: 'member3@example.com'
-            });
-            core.setWorkspaceUserDisabled('member-u3', 'workspace-seat', true);
-            core.inviteWorkspaceUser({
-                workspaceId: 'workspace-seat',
-                email: 'invite4@example.com',
-                role: 'member'
-            });
-            const initial = core.countWorkspaceSeatUsage('workspace-seat', { includeInvited: true });
-            expect(initial.used).toBe(4);
-            expect(initial.limit).toBe(5);
-            expect(initial.remaining).toBe(1);
-            const inviteUser = core.listWorkspaceUsers('workspace-seat').find((item) => item.email === 'invite4@example.com');
-            expect(inviteUser?.status).toBe('invited');
-            core.removeWorkspaceUser(String(inviteUser?.userId || ''), 'workspace-seat');
-            const afterRemoval = core.countWorkspaceSeatUsage('workspace-seat', { includeInvited: true });
-            expect(afterRemoval.used).toBe(3);
-            expect(afterRemoval.remaining).toBe(2);
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('blocks collaboration features when entitlement state is suspended', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-suspend', name: 'Suspend Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-suspend',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.setUserAccountPlanMode('owner-u1', 'team');
-            core.updateAccountEntitlement({
-                accountId: 'owner-u1',
-                entitlementState: 'suspended',
-                reason: 'billing hold',
-                actorUserId: 'system-admin',
-                actorRole: 'system_admin'
-            });
-            const evaluation = core.evaluateFeatureAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-suspend',
-                featureKey: 'collaboration.invites'
-            });
-            expect(evaluation.allowed).toBe(false);
-            expect(evaluation.reasonCode).toBe('ENTITLEMENT_STATE_BLOCKED');
-            expect(core.getAccountAccessStatus('owner-u1')).toEqual(expect.objectContaining({
-                gate: 'missing_entitlement',
-                canAccessApp: false,
-                canAccessPlans: true,
-                hasEntitlement: true
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('enforces seat limits on invite path', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-cap', name: 'Cap Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-cap',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.createPlanVersion({
-                planId: 'team-5',
-                versionNumber: 3,
-                isDefault: false,
-                seatLimit: 2
-            });
-            core.updatePlanVersionFeatures({
-                planVersionId: 'team-5-v3',
-                features: [
-                    { featureKey: 'collaboration.invites', access: 'enabled' },
-                    { featureKey: 'collaboration.team_management', access: 'enabled' },
-                    { featureKey: 'collaboration.seat_limit', access: 'limited', config: { seat_limit: 2 } }
-                ]
-            });
-            core.updateAccountEntitlement({
-                accountId: 'owner-u1',
-                planVersionId: 'team-5-v3',
-                entitlementState: 'active',
-                actorUserId: 'system-admin',
-                actorRole: 'system_admin'
-            });
-            core.ensureBootstrapUserAccess({
-                userId: 'member-u2',
-                workspaceId: 'workspace-cap',
-                role: 'member',
-                email: 'member2@example.com'
-            });
-            expect(() => {
-                core.inviteWorkspaceUser({
-                    workspaceId: 'workspace-cap',
-                    email: 'member3@example.com',
-                    role: 'member'
-                });
-            }).toThrowError(/Seat limit reached/);
-            expect(() => core.assertSeatAvailable('workspace-cap')).toThrowError(/Seat limit reached/);
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('enforces workspace limits from the workspaces feature config', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.updatePlanVersionFeatures({
-                planVersionId: 'free-v1',
-                features: [
-                    { featureKey: 'workspace.workspaces', access: 'limited', config: { maxWorkspaces: 1 } }
-                ]
-            });
-            core.createWorkspace({ workspaceId: 'workspace-one', name: 'Workspace One' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-one',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.updateAccountEntitlement({
-                accountId: 'owner-u1',
-                planVersionId: 'free-v1',
-                entitlementState: 'active',
-                actorUserId: 'system-admin',
-                actorRole: 'system_admin'
-            });
-            expect(() => {
-                core.createWorkspaceForUser({
-                    userId: 'owner-u1',
-                    name: 'Workspace Two'
-                });
-            }).toThrowError(TaskforceRuleError);
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('enforces limited document cloud storage allowances by current usage plus requested upload size', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.updatePlanVersionFeatures({
-                planVersionId: 'free-v1',
-                features: [
-                    { featureKey: 'context.uploads', access: 'limited', config: { storageLimitMb: 1 } }
-                ]
-            });
-            core.createWorkspace({ workspaceId: 'workspace-storage', name: 'Storage Workspace' });
-            core.ensureBootstrapUserAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-storage',
-                role: 'owner',
-                email: 'owner@example.com'
-            });
-            core.updateAccountEntitlement({
-                accountId: 'owner-u1',
-                planVersionId: 'free-v1',
-                entitlementState: 'active',
-                actorUserId: 'system-admin',
-                actorRole: 'system_admin'
-            });
-            const store = new WorkspaceAssetStore(core.getDatabaseAdapter(), core.getTenantId());
-            store.upsertAsset({
-                assetId: 'asset-storage-1',
-                workspaceId: 'workspace-storage',
-                kind: 'document',
-                originalFilename: 'existing.pdf',
-                mimeType: 'application/pdf',
-                storageProvider: 'local',
-                storageKey: 'workspaces/workspace-storage/assets/documents/asset-storage-1-existing.pdf',
-                contentSha256: 'existing-hash',
-                sizeBytes: 900_000,
-                documentId: 'document-storage-1',
-                version: 1,
-                isLatest: true
-            });
-            const withinLimit = core.evaluateFeatureAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-storage',
-                featureKey: 'context.uploads',
-                context: { requestedBytes: 100_000 }
-            });
-            expect(withinLimit.allowed).toBe(true);
-            expect(withinLimit.reasonCode).toBe('OK');
-            const overLimit = core.evaluateFeatureAccess({
-                userId: 'owner-u1',
-                workspaceId: 'workspace-storage',
-                featureKey: 'context.uploads',
-                context: { requestedBytes: 200_000 }
-            });
-            expect(overLimit.allowed).toBe(false);
-            expect(overLimit.reasonCode).toBe('UPLOAD_STORAGE_LIMIT_REACHED');
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-});

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

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

package/dist/core/GlobalSettingsService.test.js

@@ -1,45 +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 makeProjectRoot() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-global-settings-'));
-    roots.push(root);
-    return root;
-}
-afterEach(() => {
-    while (roots.length > 0) {
-        const root = roots.pop();
-        if (root)
-            fs.rmSync(root, { recursive: true, force: true });
-    }
-});
-describe('TaskforceCore global site settings', () => {
-    it('persists pricing page title and description', () => {
-        const projectRoot = makeProjectRoot();
-        const storagePath = '.taskforce';
-        const core = new TaskforceCore({ projectRoot, storagePath });
-        core.updateGlobalSettings({
-            site: {
-                pricingPageTitle: 'Choose Your Plan',
-                pricingPageDescription: 'Compare plans and pick the right fit.',
-                pricingPageShowPublicDescriptions: false
-            }
-        });
-        expect(core.getGlobalSettings().site).toMatchObject({
-            pricingPageTitle: 'Choose Your Plan',
-            pricingPageDescription: 'Compare plans and pick the right fit.',
-            pricingPageShowPublicDescriptions: false
-        });
-        core.close();
-        const reopened = new TaskforceCore({ projectRoot, storagePath });
-        expect(reopened.getGlobalSettings().site).toMatchObject({
-            pricingPageTitle: 'Choose Your Plan',
-            pricingPageDescription: 'Compare plans and pick the right fit.',
-            pricingPageShowPublicDescriptions: false
-        });
-        reopened.close();
-    });
-});

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

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

package/dist/core/JsonBackupRuntime.test.js

@@ -1,155 +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 createProjectRoot(prefix) {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    roots.push(projectRoot);
-    return projectRoot;
-}
-afterEach(() => {
-    while (roots.length > 0) {
-        const root = roots.pop();
-        if (root)
-            fs.rmSync(root, { recursive: true, force: true });
-    }
-});
-describe('TaskforceCore JSON backup runtime behavior', () => {
-    it('does not persist tasks.json in cloud runtime even when project and global backup settings are enabled', () => {
-        const projectRoot = createProjectRoot('taskforce-json-backup-cloud-');
-        const core = new TaskforceCore({
-            projectRoot,
-            runtimeMode: 'cloud',
-            database: {
-                provider: 'sqlite'
-            }
-        });
-        core.updateConfig({ jsonBackupEnabled: true });
-        core.updateGlobalSettings({ jsonBackupEnabled: true });
-        core.createTask({ title: 'Cloud task' });
-        expect(core.getJsonBackupEnabled()).toBe(false);
-        expect(fs.existsSync(path.join(projectRoot, '.taskforce', 'tasks.json'))).toBe(false);
-        core.close();
-    });
-    it('persists tasks.json in local runtime when JSON backup is enabled', () => {
-        const projectRoot = createProjectRoot('taskforce-json-backup-local-');
-        const core = new TaskforceCore({
-            projectRoot,
-            runtimeMode: 'local'
-        });
-        core.updateConfig({ jsonBackupEnabled: true });
-        core.createTask({ title: 'Local task' });
-        expect(core.getJsonBackupEnabled()).toBe(true);
-        expect(fs.existsSync(path.join(projectRoot, '.taskforce', 'tasks.json'))).toBe(true);
-        core.close();
-    });
-    it('persists generic project config settings in the database instead of config.json', () => {
-        const projectRoot = createProjectRoot('taskforce-project-config-db-');
-        const core = new TaskforceCore({
-            projectRoot,
-            runtimeMode: 'local'
-        });
-        core.updateConfig({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true
-        });
-        expect(core.getConfig()).toMatchObject({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true
-        });
-        expect(core.getEffectiveTheme()).toBe('light');
-        expect(core.getJsonBackupEnabled()).toBe(true);
-        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
-        expect(JSON.parse(fs.readFileSync(configPath, 'utf-8'))).toEqual({});
-        core.close();
-        const reopened = new TaskforceCore({
-            projectRoot,
-            runtimeMode: 'local'
-        });
-        expect(reopened.getConfig()).toMatchObject({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true
-        });
-        expect(reopened.getEffectiveTheme()).toBe('light');
-        expect(reopened.getJsonBackupEnabled()).toBe(true);
-        reopened.close();
-    });
-    it('stores theme, json backup, and checklist dropdown settings per user while keeping manual complexity shared', () => {
-        const projectRoot = createProjectRoot('taskforce-project-config-user-scope-');
-        const core = new TaskforceCore({
-            projectRoot,
-            runtimeMode: 'local'
-        });
-        core.updateConfig({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true
-        }, 'default', 'user-a');
-        expect(core.getConfig('default', 'user-a')).toMatchObject({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true
-        });
-        const userBConfig = core.getConfig('default', 'user-b') || {};
-        expect(userBConfig).toMatchObject({
-            manualComplexityEnabled: true
-        });
-        expect(userBConfig.theme).toBeUndefined();
-        expect(userBConfig.jsonBackupEnabled).toBeUndefined();
-        expect(userBConfig.checklistDropdownEnabled).toBeUndefined();
-        expect(core.getEffectiveTheme('default', 'user-a')).toBe('light');
-        expect(core.getJsonBackupEnabled('default', 'user-a')).toBe(true);
-        expect(core.hasProjectThemeOverride('default', 'user-a')).toBe(true);
-        expect(core.hasProjectThemeOverride('default', 'user-b')).toBe(false);
-        core.close();
-    });
-    it('migrates legacy generic project config settings from config.json into the database', () => {
-        const projectRoot = createProjectRoot('taskforce-project-config-migration-');
-        const storagePath = path.join(projectRoot, '.taskforce');
-        fs.mkdirSync(storagePath, { recursive: true });
-        fs.writeFileSync(path.join(storagePath, 'config.json'), JSON.stringify({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true,
-            categories: [{ value: 'default', label: 'General', icon: 'Inbox' }]
-        }, null, 2));
-        const core = new TaskforceCore({
-            projectRoot,
-            runtimeMode: 'local'
-        });
-        expect(core.getConfig()).toMatchObject({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true
-        });
-        fs.writeFileSync(path.join(storagePath, 'config.json'), JSON.stringify({
-            categories: [{ value: 'default', label: 'General', icon: 'Inbox' }]
-        }, null, 2));
-        core.close();
-        const reopened = new TaskforceCore({
-            projectRoot,
-            runtimeMode: 'local'
-        });
-        expect(reopened.getConfig()).toMatchObject({
-            theme: 'light',
-            jsonBackupEnabled: true,
-            manualComplexityEnabled: true,
-            checklistDropdownEnabled: true
-        });
-        expect(reopened.getEffectiveTheme()).toBe('light');
-        expect(reopened.getJsonBackupEnabled()).toBe(true);
-        reopened.close();
-    });
-});

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

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

package/dist/core/PlanFeatureCatalog.test.js

@@ -1,139 +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-feature-catalog-'));
-}
-describe('TaskforceCore plan feature catalog marketing copy', () => {
-    it('persists public marketing copy overrides and falls back after clearing them', () => {
-        const projectRoot = makeProjectRoot();
-        const core = new TaskforceCore({
-            projectRoot,
-            storagePath: path.join(projectRoot, '.taskforce')
-        });
-        const initialFeature = core.listPlanFeatureCatalog().find((feature) => feature.featureKey === 'collaboration.ai_profiles');
-        expect(initialFeature?.label).toBe('AI Profiles');
-        expect(initialFeature?.publicLabel ?? null).toBeNull();
-        expect(initialFeature?.publicDescription ?? null).toBeNull();
-        expect(initialFeature?.publicDescriptionVisible ?? null).toBeNull();
-        expect(initialFeature?.publicDisplayOrder).toBe(20);
-        const updated = core.updatePlanFeatureCatalogMarketingCopy({
-            featureKey: 'collaboration.ai_profiles',
-            publicLabel: 'AI teammates',
-            publicDescription: 'Add reusable AI teammates to your workspace.',
-            publicDescriptionVisible: false,
-            publicDisplayOrder: 24
-        });
-        expect(updated.publicLabel).toBe('AI teammates');
-        expect(updated.publicDescription).toBe('Add reusable AI teammates to your workspace.');
-        expect(updated.publicDescriptionVisible).toBe(false);
-        expect(updated.publicDisplayOrder).toBe(24);
-        const persisted = core.listPlanFeatureCatalog().find((feature) => feature.featureKey === 'collaboration.ai_profiles');
-        expect(persisted?.publicLabel).toBe('AI teammates');
-        expect(persisted?.publicDescription).toBe('Add reusable AI teammates to your workspace.');
-        expect(persisted?.publicDescriptionVisible).toBe(false);
-        expect(persisted?.publicDisplayOrder).toBe(24);
-        const cleared = core.updatePlanFeatureCatalogMarketingCopy({
-            featureKey: 'collaboration.ai_profiles',
-            publicLabel: '   ',
-            publicDescription: '',
-            publicDescriptionVisible: null,
-            publicDisplayOrder: null
-        });
-        expect(cleared.publicLabel ?? null).toBeNull();
-        expect(cleared.publicDescription ?? null).toBeNull();
-        expect(cleared.publicDescriptionVisible ?? null).toBeNull();
-        expect(cleared.publicDisplayOrder).toBe(20);
-        const fallback = core.listPlanFeatureCatalog().find((feature) => feature.featureKey === 'collaboration.ai_profiles');
-        expect(fallback?.label).toBe('AI Profiles');
-        expect(fallback?.publicLabel ?? null).toBeNull();
-        expect(fallback?.publicDescription ?? null).toBeNull();
-        expect(fallback?.publicDescriptionVisible ?? null).toBeNull();
-        expect(fallback?.publicDisplayOrder).toBe(20);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('migrates legacy workspace feature catalog overrides to the canonical key', () => {
-        const projectRoot = makeProjectRoot();
-        const core = new TaskforceCore({
-            projectRoot,
-            storagePath: path.join(projectRoot, '.taskforce')
-        });
-        const db = core.db;
-        db.prepare(`
-            INSERT INTO plan_feature_catalog_overrides (
-                tenant_id,
-                feature_key,
-                public_label,
-                public_description,
-                public_display_order,
-                created_at,
-                updated_at
-            ) VALUES (?, 'workspace.switching', ?, ?, ?, ?, ?)
-        `).run('default', 'Workspace access', 'Let a user create and switch between multiple workspaces.', 14, '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z');
-        core.planEntitlementService.normalizeLegacyPlanDataIfNeeded();
-        const feature = core.listPlanFeatureCatalog().find((item) => item.featureKey === 'workspace.workspaces');
-        expect(feature?.publicLabel).toBe('Workspace access');
-        expect(feature?.publicDescription).toBe('Let a user create and switch between multiple workspaces.');
-        expect(feature?.publicDisplayOrder).toBe(14);
-        const rows = db.prepare(`
-            SELECT feature_key
-            FROM plan_feature_catalog_overrides
-            WHERE tenant_id = ?
-        `).all('default');
-        expect(rows.some((row) => row.feature_key === 'workspace.switching')).toBe(false);
-        expect(rows.some((row) => row.feature_key === 'workspace.workspaces')).toBe(true);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('creates, updates, and deletes custom feature catalog entries', () => {
-        const projectRoot = makeProjectRoot();
-        const core = new TaskforceCore({
-            projectRoot,
-            storagePath: path.join(projectRoot, '.taskforce')
-        });
-        const created = core.createCustomPlanFeatureCatalogEntry({
-            label: 'Unlimited Local Workspaces',
-            description: 'Run unlimited local workspaces on your device.',
-            publicDescriptionVisible: false,
-            publicDisplayOrder: 12
-        });
-        expect(created.featureKey).toMatch(/^marketing\./);
-        expect(created.isCustom).toBe(true);
-        expect(created.label).toBe('Unlimited Local Workspaces');
-        expect(created.description).toBe('Run unlimited local workspaces on your device.');
-        expect(created.publicDescriptionVisible).toBe(false);
-        expect(created.publicDisplayOrder).toBe(12);
-        const updated = core.updatePlanFeatureCatalogMarketingCopy({
-            featureKey: created.featureKey,
-            label: 'Unlimited Local Workspaces',
-            description: 'Run unlimited local workspaces offline on your device.',
-            publicLabel: 'Unlimited Local Workspaces',
-            publicDescription: 'Create as many fully local workspaces as you need.',
-            publicDescriptionVisible: true,
-            publicDisplayOrder: 14
-        });
-        expect(updated.isCustom).toBe(true);
-        expect(updated.description).toBe('Run unlimited local workspaces offline on your device.');
-        expect(updated.publicLabel).toBe('Unlimited Local Workspaces');
-        expect(updated.publicDescription).toBe('Create as many fully local workspaces as you need.');
-        expect(updated.publicDescriptionVisible).toBe(true);
-        expect(updated.publicDisplayOrder).toBe(14);
-        const plan = core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
-        expect(plan.planId).toBe('free');
-        core.updatePlanVersionFeatures({
-            planVersionId: 'free-v1',
-            features: [
-                { featureKey: created.featureKey, access: 'enabled', config: {} }
-            ]
-        });
-        expect(core.getPlanVersionFeatures('free', 'free-v1').features[created.featureKey]?.access).toBe('enabled');
-        core.deleteCustomPlanFeatureCatalogEntry(created.featureKey);
-        expect(core.listPlanFeatureCatalog().some((feature) => feature.featureKey === created.featureKey)).toBe(false);
-        expect(core.getPlanVersionFeatures('free', 'free-v1').features[created.featureKey]).toBeUndefined();
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-});

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

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