@taskforcehq/taskforce 0.3.304 → 0.3.305

package/dist/core/EntitlementsPolicy.test.js

@@ -3,6 +3,7 @@ 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-'));
 }
@@ -20,20 +21,20 @@ function openCore(projectRoot) {
             ) 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.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: 'collab',
+        planId: 'team-5',
         versionNumber: 2,
         isDefault: true,
         seatLimit: 5
     });
     core.updatePlanVersionFeatures({
-        planVersionId: 'collab-v2',
+        planVersionId: 'team-5-v2',
         features: [
             { featureKey: 'collaboration.invites', access: 'enabled' },
             { featureKey: 'collaboration.team_management', access: 'enabled' },
@@ -139,13 +140,13 @@ describe('Taskforce entitlements policy engine', () => {
                 email: 'owner@example.com'
             });
             core.createPlanVersion({
-                planId: 'collab',
+                planId: 'team-5',
                 versionNumber: 3,
                 isDefault: false,
                 seatLimit: 2
             });
             core.updatePlanVersionFeatures({
-                planVersionId: 'collab-v3',
+                planVersionId: 'team-5-v3',
                 features: [
                     { featureKey: 'collaboration.invites', access: 'enabled' },
                     { featureKey: 'collaboration.team_management', access: 'enabled' },
@@ -154,7 +155,7 @@ describe('Taskforce entitlements policy engine', () => {
             });
             core.updateAccountEntitlement({
                 accountId: 'owner-u1',
-                planVersionId: 'collab-v3',
+                planVersionId: 'team-5-v3',
                 entitlementState: 'active',
                 actorUserId: 'system-admin',
                 actorRole: 'system_admin'
@@ -184,7 +185,7 @@ describe('Taskforce entitlements policy engine', () => {
         const core = openCore(projectRoot);
         try {
             core.updatePlanVersionFeatures({
-                planVersionId: 'starter-v1',
+                planVersionId: 'free-v1',
                 features: [
                     { featureKey: 'workspace.switching', access: 'limited', config: { maxWorkspaces: 1 } }
                 ]
@@ -198,7 +199,7 @@ describe('Taskforce entitlements policy engine', () => {
             });
             core.updateAccountEntitlement({
                 accountId: 'owner-u1',
-                planVersionId: 'starter-v1',
+                planVersionId: 'free-v1',
                 entitlementState: 'active',
                 actorUserId: 'system-admin',
                 actorRole: 'system_admin'
@@ -215,4 +216,65 @@ describe('Taskforce entitlements policy engine', () => {
             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/PlanEntitlementService.d.ts

@@ -29,6 +29,7 @@ export declare class PlanEntitlementService {
     private readAccountEntitlementRow;
     private normalizeExpiredCheckoutPendingRow;
     private isBillingConfirmedTransitionSource;
+    private countWorkspaceStorageUsageBytes;
     private resolveCanonicalTransitionSource;
     private resolvePendingPlanVersionId;
     private buildBlockedAccessStatus;
@@ -73,6 +74,10 @@ export declare class PlanEntitlementService {
         limit: number | null;
         feature: PlanFeatureSnapshot | null;
     };
+    resolveAiProfileLimitForWorkspace(workspaceId: string): {
+        limit: number | null;
+        feature: PlanFeatureSnapshot | null;
+    };
     private planHasAnyActivePricing;
     private planVersionHasActiveFreePricing;
     private planVersionIsTrialEligible;
@@ -80,7 +85,6 @@ export declare class PlanEntitlementService {
     private getActiveDefaultPlanVersions;
     private getDefaultPlanVersionByMode;
     private tryGetDefaultPlanVersionByMode;
-    private tryGetImplicitFreeOnboardingPlanVersion;
     getOnboardingPolicy(): OnboardingPolicy;
     validateOnboardingPolicy(input?: Partial<OnboardingPolicy>): OnboardingPolicyValidationResult;
     resolveRegistrationOnboardingOutcome(selectedPlanVersionIdRaw?: string): {
@@ -101,12 +105,14 @@ export declare class PlanEntitlementService {
     };
     hasAccountEntitlement(accountId: string): boolean;
     private tryGetAccountEntitlement;
+    private tryAutoHealLegacyPersonalFreeEntitlement;
     getAccountAccessStatus(accountId: string): AccountAccessStatus;
     getEffectivePlanVersion(accountId: string): PlanVersionSnapshot;
     getAccountEntitlement(accountId: string): AccountEntitlementSnapshot;
     countWorkspaceSeatUsage(workspaceId: string, options?: {
         includeInvited?: boolean;
     }): SeatUsageSnapshot;
+    countAiProfileUsage(workspaceId: string): SeatUsageSnapshot;
     assertSeatAvailable(workspaceId: string): void;
     evaluateFeatureAccess(input: {
         userId: string;

package/dist/core/PlanEntitlementService.js

@@ -1,5 +1,5 @@
 import { TaskforceRuleError } from './types.js';
-import { DOCUMENT_CLOUD_STORAGE_FEATURE_KEY, WORKSPACES_FEATURE_KEY, DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY, WORKSPACES_LIMIT_CONFIG_KEY, DEFAULT_PLAN_FEATURE_CATALOG, PLAN_FEATURE_DEPENDENCIES, generateUuidV7, } from './shared.js';
+import { DOCUMENT_CLOUD_STORAGE_FEATURE_KEY, WORKSPACES_FEATURE_KEY, AI_PROFILES_FEATURE_KEY, DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY, WORKSPACES_LIMIT_CONFIG_KEY, AI_PROFILES_LIMIT_CONFIG_KEY, DEFAULT_PLAN_FEATURE_CATALOG, PLAN_FEATURE_DEPENDENCIES, generateUuidV7, } from './shared.js';
 const LEGACY_REMOVED_PLAN_FEATURE_KEYS = Object.freeze([
     'documents.workspace_access'
 ]);
@@ -113,6 +113,15 @@ export class PlanEntitlementService {
                 [WORKSPACES_LIMIT_CONFIG_KEY]: limit ?? 1
             };
         }
+        if (featureKey === AI_PROFILES_FEATURE_KEY) {
+            if (access === 'limited') {
+                const limit = this.readPositiveIntegerConfig(config[AI_PROFILES_LIMIT_CONFIG_KEY], 1);
+                return {
+                    [AI_PROFILES_LIMIT_CONFIG_KEY]: limit ?? 1
+                };
+            }
+            return {};
+        }
         return config && typeof config === 'object' ? { ...config } : {};
     }
     isEntitlementStateAllowed(state) {
@@ -160,6 +169,20 @@ export class PlanEntitlementService {
     isBillingConfirmedTransitionSource(source) {
         return source === 'checkout-confirm' || source === 'stripe-webhook';
     }
+    countWorkspaceStorageUsageBytes(workspaceIdRaw) {
+        const workspaceId = String(workspaceIdRaw || '').trim();
+        if (!workspaceId)
+            return 0;
+        const row = this.db.prepare(`
+            SELECT COALESCE(SUM(size_bytes), 0) AS total_bytes
+            FROM workspace_assets
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND deleted_at IS NULL
+        `).get(this.tenantId, workspaceId);
+        const total = Number(row?.total_bytes || 0);
+        return Number.isFinite(total) ? Math.max(0, Math.floor(total)) : 0;
+    }
     resolveCanonicalTransitionSource(updatedBy) {
         if (updatedBy === 'registration'
             || updatedBy === 'checkout-start'
@@ -534,6 +557,32 @@ export class PlanEntitlementService {
         }
         return { limit: null, feature };
     }
+    resolveAiProfileLimitForWorkspace(workspaceId) {
+        const normalizedWorkspaceId = String(workspaceId || '').trim();
+        if (!normalizedWorkspaceId) {
+            return { limit: null, feature: null };
+        }
+        const accountId = this.deps.getWorkspaceOwnerUserId(normalizedWorkspaceId);
+        if (!accountId) {
+            return { limit: null, feature: null };
+        }
+        let entitlement;
+        try {
+            entitlement = this.getAccountEntitlement(accountId);
+        }
+        catch (error) {
+            if (error instanceof TaskforceRuleError && error.code === 'ENTITLEMENT_NOT_FOUND') {
+                return { limit: null, feature: null };
+            }
+            throw error;
+        }
+        const feature = entitlement.version.features[AI_PROFILES_FEATURE_KEY] || null;
+        if (!feature || feature.access !== 'limited') {
+            return { limit: null, feature };
+        }
+        const configuredLimit = this.readPositiveIntegerConfig(feature.config?.[AI_PROFILES_LIMIT_CONFIG_KEY], 1);
+        return { limit: configuredLimit ?? 1, feature };
+    }
     planHasAnyActivePricing(planIdRaw) {
         const planId = String(planIdRaw || '').trim().toLowerCase();
         if (!planId)
@@ -629,33 +678,6 @@ export class PlanEntitlementService {
             throw error;
         }
     }
-    tryGetImplicitFreeOnboardingPlanVersion() {
-        const rows = this.db.prepare(`
-            SELECT DISTINCT v.plan_version_id
-            FROM plan_versions v
-            JOIN plan_catalog p
-              ON p.tenant_id = v.tenant_id
-             AND p.plan_id = v.plan_id
-            JOIN billing_price_mappings bpm
-              ON bpm.tenant_id = v.tenant_id
-             AND bpm.plan_version_id = v.plan_version_id
-            WHERE v.tenant_id = ?
-              AND COALESCE(p.status, 'active') = 'active'
-              AND bpm.active = 1
-              AND bpm.pricing_type = 'free'
-            ORDER BY v.is_default DESC, p.updated_at DESC, p.created_at DESC, v.version_number DESC, v.created_at DESC
-        `).all(this.tenantId);
-        for (const row of rows) {
-            const planVersionId = String(row.plan_version_id || '').trim();
-            if (!planVersionId)
-                continue;
-            const version = this.getPlanVersionSnapshot(planVersionId);
-            if (!this.isTeamPlanVersion(version)) {
-                return version;
-            }
-        }
-        return null;
-    }
     getOnboardingPolicy() {
         const billing = this.deps.readGlobalConfig().billing || {};
         const policy = billing.onboardingPolicy && typeof billing.onboardingPolicy === 'object'
@@ -671,13 +693,6 @@ export class PlanEntitlementService {
                     : null
             };
         }
-        const implicitFreeVersion = this.tryGetImplicitFreeOnboardingPlanVersion();
-        if (implicitFreeVersion) {
-            return {
-                mode: 'auto_grant_free',
-                planVersionId: implicitFreeVersion.planVersionId
-            };
-        }
         return {
             mode: 'require_plan_selection',
             planVersionId: null
@@ -755,7 +770,12 @@ export class PlanEntitlementService {
     }
     resolveRegistrationOnboardingOutcome(selectedPlanVersionIdRaw) {
         const selectedPlanVersionId = String(selectedPlanVersionIdRaw || '').trim();
-        if (selectedPlanVersionId) {
+        const onboardingPolicy = this.getOnboardingPolicy();
+        const validation = this.validateOnboardingPolicy(onboardingPolicy);
+        if (!validation.valid) {
+            throw new TaskforceRuleError(validation.message || 'Onboarding policy is misconfigured.', 500, validation.code || 'ONBOARDING_POLICY_INVALID', validation.details);
+        }
+        if (onboardingPolicy.mode === 'require_plan_selection' && selectedPlanVersionId) {
             const planVersion = this.getPlanVersionSnapshot(selectedPlanVersionId);
             const commercialState = this.planVersionHasActiveFreePricing(planVersion.planVersionId)
                 ? 'active'
@@ -768,11 +788,6 @@ export class PlanEntitlementService {
                 planId: planVersion.planId
             };
         }
-        const onboardingPolicy = this.getOnboardingPolicy();
-        const validation = this.validateOnboardingPolicy(onboardingPolicy);
-        if (!validation.valid) {
-            throw new TaskforceRuleError(validation.message || 'Onboarding policy is misconfigured.', 500, validation.code || 'ONBOARDING_POLICY_INVALID', validation.details);
-        }
         if (onboardingPolicy.mode === 'require_plan_selection') {
             return {
                 requiresPlanSelection: true,
@@ -844,6 +859,34 @@ export class PlanEntitlementService {
             throw error;
         }
     }
+    tryAutoHealLegacyPersonalFreeEntitlement(accountId, entitlement) {
+        if (entitlement.state !== 'canceled')
+            return null;
+        if (this.isTeamPlanVersion(entitlement.version))
+            return null;
+        const defaultPersonalVersion = this.tryGetDefaultPlanVersionByMode('personal');
+        if (!defaultPersonalVersion)
+            return null;
+        if (!this.planVersionHasActiveFreePricing(defaultPersonalVersion.planVersionId))
+            return null;
+        if (String(entitlement.planId || '').trim().toLowerCase() !== defaultPersonalVersion.planId)
+            return null;
+        if (entitlement.planVersionId === defaultPersonalVersion.planVersionId)
+            return null;
+        if (entitlement.version.versionNumber >= defaultPersonalVersion.versionNumber)
+            return null;
+        return this.transitionCanonicalCommercialState({
+            accountId,
+            planVersionId: defaultPersonalVersion.planVersionId,
+            state: 'active',
+            effectiveAt: entitlement.effectiveAt,
+            effectiveUntil: null,
+            billingMirrorPlanId: defaultPersonalVersion.planId,
+            source: 'system',
+            updatedBy: 'legacy-free-auto-heal',
+            createdAt: entitlement.effectiveAt
+        });
+    }
     getAccountAccessStatus(accountId) {
         const normalizedAccountId = String(accountId || '').trim();
         if (!normalizedAccountId) {
@@ -851,7 +894,10 @@ export class PlanEntitlementService {
         }
         const onboardingPolicy = this.getOnboardingPolicy();
         const validation = this.validateOnboardingPolicy(onboardingPolicy);
-        const entitlement = this.tryGetAccountEntitlement(normalizedAccountId);
+        const currentEntitlement = this.tryGetAccountEntitlement(normalizedAccountId);
+        const entitlement = currentEntitlement
+            ? (this.tryAutoHealLegacyPersonalFreeEntitlement(normalizedAccountId, currentEntitlement) || currentEntitlement)
+            : null;
         if (!entitlement) {
             return !validation.valid
                 ? this.buildBlockedAccessStatus({
@@ -989,6 +1035,22 @@ export class PlanEntitlementService {
         const remaining = limit === null ? null : Math.max(0, limit - used);
         return { used, limit, remaining };
     }
+    countAiProfileUsage(workspaceId) {
+        const normalizedWorkspaceId = String(workspaceId || '').trim();
+        if (!normalizedWorkspaceId) {
+            throw new TaskforceRuleError('workspaceId is required', 400, 'WORKSPACE_ID_REQUIRED');
+        }
+        const row = this.db.prepare(`
+            SELECT COUNT(*) AS c
+            FROM ai_profiles
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+        `).get(this.tenantId, normalizedWorkspaceId);
+        const used = Math.max(0, Number(row?.c || 0));
+        const { limit } = this.resolveAiProfileLimitForWorkspace(normalizedWorkspaceId);
+        const remaining = limit === null ? null : Math.max(0, limit - used);
+        return { used, limit, remaining };
+    }
     assertSeatAvailable(workspaceId) {
         const seatUsage = this.countWorkspaceSeatUsage(workspaceId, { includeInvited: true });
         if (seatUsage.limit !== null && seatUsage.used >= seatUsage.limit) {
@@ -1026,6 +1088,19 @@ export class PlanEntitlementService {
             }
             return { allowed: true, reasonCode: 'OK', state: entitlement.state, seatUsage, feature };
         }
+        if (featureKey === DOCUMENT_CLOUD_STORAGE_FEATURE_KEY && feature.access === 'limited') {
+            const configuredLimitMb = this.readPositiveIntegerConfig(feature.config?.[DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY], 1) ?? 1;
+            const storageLimitBytes = configuredLimitMb * 1024 * 1024;
+            const rawRequestedBytes = input.context?.requestedBytes ?? input.context?.sizeBytes ?? input.context?.pendingSizeBytes;
+            const requestedBytesNumber = Number(rawRequestedBytes);
+            const requestedBytes = Number.isFinite(requestedBytesNumber)
+                ? Math.max(0, Math.floor(requestedBytesNumber))
+                : 0;
+            const usedBytes = this.countWorkspaceStorageUsageBytes(workspaceId);
+            if ((usedBytes + requestedBytes) > storageLimitBytes) {
+                return { allowed: false, reasonCode: 'UPLOAD_STORAGE_LIMIT_REACHED', state: entitlement.state, feature };
+            }
+        }
         return { allowed: true, reasonCode: 'OK', state: entitlement.state, feature };
     }
     getUserAccountPlanMode(userId) {

package/dist/core/PlanVersionPolicy.test.js

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { TaskforceCore, TaskforceRuleError } from './Taskforce';
+import { TaskforceCore } from './Taskforce';
 function makeProjectRoot() {
     return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-plan-version-policy-'));
 }
@@ -11,8 +11,8 @@ function openCore(projectRoot) {
         projectRoot,
         storagePath: path.join(projectRoot, '.taskforce')
     });
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'archived' });
-    core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab', status: 'archived' });
+    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'archived' });
+    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'archived' });
     return core;
 }
 describe('TaskforceCore plan version policy', () => {
@@ -20,17 +20,17 @@ describe('TaskforceCore plan version policy', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
-            core.createPlanVersion({ planId: 'starter', versionNumber: 2, isDefault: false });
+            core.createPlanVersion({ planId: 'free', versionNumber: 2, isDefault: false });
             const db = core.db;
             db.prepare(`
                 UPDATE plan_versions
                 SET is_default = 0
                 WHERE tenant_id = ? AND plan_id = ?
-            `).run('default', 'starter');
-            const versions = core.listPlanVersions('starter');
+            `).run('default', 'free');
+            const versions = core.listPlanVersions('free');
             const defaults = versions.filter((version) => version.isDefault);
             expect(defaults).toHaveLength(1);
-            expect(defaults[0].planVersionId).toBe('starter-v2');
+            expect(defaults[0].planVersionId).toBe('free-v2');
         }
         finally {
             core.close();
@@ -43,11 +43,11 @@ describe('TaskforceCore plan version policy', () => {
         try {
             expect(() => {
                 core.updatePlanVersion({
-                    planId: 'starter',
+                    planId: 'free',
                     versionNumber: 1,
                     isDefault: false
                 });
-            }).toThrowError(TaskforceRuleError);
+            }).toThrowError(/exactly one default version/i);
         }
         finally {
             core.close();
@@ -59,13 +59,13 @@ describe('TaskforceCore plan version policy', () => {
         const core = openCore(projectRoot);
         try {
             core.createPlanVersion({
-                planId: 'collab',
+                planId: 'team-5',
                 versionNumber: 2,
                 isDefault: true,
                 seatLimit: 3
             });
             core.updatePlanVersionFeatures({
-                planVersionId: 'collab-v2',
+                planVersionId: 'team-5-v2',
                 features: [
                     {
                         featureKey: 'collaboration.seat_limit',
@@ -74,7 +74,7 @@ describe('TaskforceCore plan version policy', () => {
                     }
                 ]
             });
-            const version = core.getPlanVersionFeatures('collab', 'collab-v2');
+            const version = core.getPlanVersionFeatures('team-5', 'team-5-v2');
             expect(version.seatLimit).toBe(3);
             expect(version.features['collaboration.seat_limit']?.config || {}).toEqual({});
         }
@@ -109,19 +109,19 @@ describe('TaskforceCore plan version policy', () => {
         const core = openCore(projectRoot);
         try {
             core.updatePlanVersion({
-                planId: 'collab',
+                planId: 'team-5',
                 versionNumber: 1,
                 seatLimit: 5
             });
             core.updatePlanVersionFeatures({
-                planVersionId: 'collab-v1',
+                planVersionId: 'team-5-v1',
                 features: [
                     { featureKey: 'collaboration.invites', access: 'enabled', config: {} },
                     { featureKey: 'collaboration.team_management', access: 'enabled', config: {} }
                 ]
             });
             const version = core.updatePlanVersionFeatures({
-                planVersionId: 'collab-v1',
+                planVersionId: 'team-5-v1',
                 features: [
                     { featureKey: 'collaboration.team_management', access: 'disabled', config: {} }
                 ]
@@ -139,7 +139,7 @@ describe('TaskforceCore plan version policy', () => {
         const core = openCore(projectRoot);
         try {
             const version = core.updatePlanVersionFeatures({
-                planVersionId: 'starter-v1',
+                planVersionId: 'free-v1',
                 features: [
                     { featureKey: 'workspace.switching', access: 'limited', config: { maxWorkspaces: 0 } },
                     { featureKey: 'context.uploads', access: 'limited', config: { storageLimitMb: -50 } }
@@ -153,22 +153,15 @@ describe('TaskforceCore plan version policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('starts new plans disabled and rejects enabling plans without pricing', () => {
+    it('starts new plans disabled before pricing is configured', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
             const created = core.upsertPlanCatalog({
-                planId: 'enterprise',
-                displayName: 'Enterprise'
+                planId: 'agency',
+                displayName: 'Agency'
             });
             expect(created.status).toBe('archived');
-            expect(() => {
-                core.upsertPlanCatalog({
-                    planId: 'enterprise',
-                    displayName: 'Enterprise',
-                    status: 'active'
-                });
-            }).toThrowError(TaskforceRuleError);
         }
         finally {
             core.close();