@taskforcehq/taskforce 0.3.307 → 0.3.308

package/dist/core/PlanEntitlementService.js

@@ -4,6 +4,7 @@ const LEGACY_REMOVED_PLAN_FEATURE_KEYS = Object.freeze([
     'documents.workspace_access'
 ]);
 const LEGACY_WORKSPACES_FEATURE_KEY = 'workspace.switching';
+const CUSTOM_PLAN_FEATURE_KEY_PREFIX = 'marketing.';
 /**
  * Handles all plan catalog, plan version, and account entitlement logic.
  * Extracted from Taskforce.ts to reduce monolith size.
@@ -49,9 +50,105 @@ export class PlanEntitlementService {
             return null;
         return Math.max(0, Math.floor(numeric));
     }
+    normalizeOptionalCatalogDescriptionVisible(raw) {
+        if (raw === null || raw === undefined || raw === '')
+            return null;
+        return raw === false || raw === 0 || raw === '0' ? false : true;
+    }
+    isBuiltInPlanFeatureKey(featureKey) {
+        return DEFAULT_PLAN_FEATURE_CATALOG.some((feature) => feature.featureKey === featureKey);
+    }
+    normalizeRequiredCatalogLabel(raw) {
+        return String(raw ?? '').trim();
+    }
+    slugifyCustomPlanFeatureLabel(label) {
+        const base = label
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .replace(/^_+|_+$/g, '');
+        return base || generateUuidV7().replace(/-/g, '_');
+    }
+    featureKeyExists(featureKey) {
+        if (this.isBuiltInPlanFeatureKey(featureKey))
+            return true;
+        const row = this.db.prepare(`
+            SELECT 1
+            FROM plan_feature_catalog_overrides
+            WHERE tenant_id = ? AND feature_key = ?
+            LIMIT 1
+        `).get(this.tenantId, featureKey);
+        return Boolean(row);
+    }
+    generateUniqueCustomPlanFeatureKey(label) {
+        const base = `${CUSTOM_PLAN_FEATURE_KEY_PREFIX}${this.slugifyCustomPlanFeatureLabel(label)}`;
+        let featureKey = base;
+        let suffix = 2;
+        while (this.featureKeyExists(featureKey)) {
+            featureKey = `${base}_${suffix}`;
+            suffix += 1;
+        }
+        return featureKey;
+    }
+    listCustomPlanFeatureCatalogEntries() {
+        const rows = this.db.prepare(`
+            SELECT feature_key, label, description, public_label, public_description, public_description_visible, public_display_order
+            FROM plan_feature_catalog_overrides
+            WHERE tenant_id = ? AND is_custom = 1
+            ORDER BY updated_at ASC, created_at ASC, feature_key ASC
+        `).all(this.tenantId);
+        const features = [];
+        for (const row of rows) {
+            const featureKey = this.canonicalizePlanFeatureKey(row.feature_key);
+            const label = this.normalizeRequiredCatalogLabel(row.label);
+            if (!featureKey || !label)
+                continue;
+            features.push({
+                featureKey,
+                label,
+                description: this.normalizeRequiredCatalogLabel(row.description),
+                isCustom: true,
+                publicLabel: this.normalizeOptionalCatalogMarketingCopy(row.public_label),
+                publicDescription: this.normalizeOptionalCatalogMarketingCopy(row.public_description),
+                publicDescriptionVisible: this.normalizeOptionalCatalogDescriptionVisible(row.public_description_visible),
+                publicDisplayOrder: this.normalizeOptionalCatalogDisplayOrder(row.public_display_order),
+                allowedAccessModes: ['enabled', 'disabled'],
+                configTemplate: {}
+            });
+        }
+        return features;
+    }
+    getCustomPlanFeatureCatalogEntry(featureKeyRaw) {
+        const featureKey = this.canonicalizePlanFeatureKey(featureKeyRaw);
+        if (!featureKey)
+            return null;
+        const row = this.db.prepare(`
+            SELECT feature_key, label, description, public_label, public_description, public_description_visible, public_display_order
+            FROM plan_feature_catalog_overrides
+            WHERE tenant_id = ? AND feature_key = ? AND is_custom = 1
+            LIMIT 1
+        `).get(this.tenantId, featureKey);
+        if (!row)
+            return null;
+        const label = this.normalizeRequiredCatalogLabel(row.label);
+        if (!label)
+            return null;
+        return {
+            featureKey,
+            label,
+            description: this.normalizeRequiredCatalogLabel(row.description),
+            isCustom: true,
+            publicLabel: this.normalizeOptionalCatalogMarketingCopy(row.public_label),
+            publicDescription: this.normalizeOptionalCatalogMarketingCopy(row.public_description),
+            publicDescriptionVisible: this.normalizeOptionalCatalogDescriptionVisible(row.public_description_visible),
+            publicDisplayOrder: this.normalizeOptionalCatalogDisplayOrder(row.public_display_order),
+            allowedAccessModes: ['enabled', 'disabled'],
+            configTemplate: {}
+        };
+    }
     listPlanFeatureCatalogOverrideMap() {
         const rows = this.db.prepare(`
-            SELECT feature_key, public_label, public_description, public_display_order
+            SELECT feature_key, public_label, public_description, public_description_visible, public_display_order, is_custom
             FROM plan_feature_catalog_overrides
             WHERE tenant_id = ?
         `).all(this.tenantId);
@@ -61,12 +158,15 @@ export class PlanEntitlementService {
             const featureKey = this.canonicalizePlanFeatureKey(originalFeatureKey);
             if (!featureKey)
                 continue;
+            if (Number(row.is_custom || 0) === 1)
+                continue;
             if (featureKey === WORKSPACES_FEATURE_KEY && originalFeatureKey === LEGACY_WORKSPACES_FEATURE_KEY && overrides.has(featureKey)) {
                 continue;
             }
             overrides.set(featureKey, {
                 publicLabel: this.normalizeOptionalCatalogMarketingCopy(row.public_label),
                 publicDescription: this.normalizeOptionalCatalogMarketingCopy(row.public_description),
+                publicDescriptionVisible: this.normalizeOptionalCatalogDescriptionVisible(row.public_description_visible),
                 publicDisplayOrder: this.normalizeOptionalCatalogDisplayOrder(row.public_display_order)
             });
         }
@@ -689,6 +789,7 @@ export class PlanEntitlementService {
             WHERE bpm.tenant_id = ?
               AND pv.plan_id = ?
               AND bpm.active = 1
+              AND COALESCE(bpm.pricing_audience, 'public') = 'public'
         `).get(this.tenantId, planId);
         return Number(row?.count || 0) > 0;
     }
@@ -702,6 +803,7 @@ export class PlanEntitlementService {
             WHERE tenant_id = ?
               AND plan_version_id = ?
               AND active = 1
+              AND COALESCE(pricing_audience, 'public') = 'public'
               AND pricing_type = 'free'
         `).get(this.tenantId, planVersionId);
         return Number(row?.count || 0) > 0;
@@ -1054,7 +1156,7 @@ export class PlanEntitlementService {
             const mappingRow = this.db.prepare(`
                 SELECT plan_version_id
                 FROM billing_price_mappings
-                WHERE tenant_id = ? AND stripe_price_id = ? AND active = 1
+                WHERE tenant_id = ? AND stripe_price_id = ? AND active = 1 AND COALESCE(pricing_audience, 'public') = 'public'
                 ORDER BY updated_at DESC, created_at DESC
                 LIMIT 1
             `).get(this.tenantId, stripePriceId);
@@ -1490,31 +1592,104 @@ export class PlanEntitlementService {
     }
     listPlanFeatureCatalog() {
         const overrides = this.listPlanFeatureCatalogOverrideMap();
-        return DEFAULT_PLAN_FEATURE_CATALOG.map((feature) => ({
-            featureKey: feature.featureKey,
-            label: feature.label,
-            description: feature.description,
-            publicLabel: overrides.get(feature.featureKey)?.publicLabel ?? feature.publicLabel ?? null,
-            publicDescription: overrides.get(feature.featureKey)?.publicDescription ?? feature.publicDescription ?? null,
-            publicDisplayOrder: overrides.get(feature.featureKey)?.publicDisplayOrder ?? feature.publicDisplayOrder ?? null,
-            allowedAccessModes: [...feature.allowedAccessModes],
-            configTemplate: { ...feature.configTemplate },
-            ...(feature.dependsOn?.length ? { dependsOn: [...feature.dependsOn] } : {})
-        }));
+        return [
+            ...DEFAULT_PLAN_FEATURE_CATALOG.map((feature) => ({
+                featureKey: feature.featureKey,
+                label: feature.label,
+                description: feature.description,
+                isCustom: false,
+                publicLabel: overrides.get(feature.featureKey)?.publicLabel ?? feature.publicLabel ?? null,
+                publicDescription: overrides.get(feature.featureKey)?.publicDescription ?? feature.publicDescription ?? null,
+                publicDescriptionVisible: overrides.get(feature.featureKey)?.publicDescriptionVisible ?? feature.publicDescriptionVisible ?? null,
+                publicDisplayOrder: overrides.get(feature.featureKey)?.publicDisplayOrder ?? feature.publicDisplayOrder ?? null,
+                allowedAccessModes: [...feature.allowedAccessModes],
+                configTemplate: { ...feature.configTemplate },
+                ...(feature.dependsOn?.length ? { dependsOn: [...feature.dependsOn] } : {})
+            })),
+            ...this.listCustomPlanFeatureCatalogEntries()
+        ];
+    }
+    createCustomPlanFeatureCatalogEntry(input) {
+        const label = this.normalizeRequiredCatalogLabel(input.label);
+        const description = this.normalizeRequiredCatalogLabel(input.description);
+        if (!label)
+            throw new TaskforceRuleError('Feature label is required', 400, 'PLAN_FEATURE_LABEL_REQUIRED');
+        const featureKey = this.generateUniqueCustomPlanFeatureKey(label);
+        const publicLabel = this.normalizeOptionalCatalogMarketingCopy(input.publicLabel);
+        const publicDescription = this.normalizeOptionalCatalogMarketingCopy(input.publicDescription);
+        const publicDescriptionVisible = this.normalizeOptionalCatalogDescriptionVisible(input.publicDescriptionVisible);
+        const publicDisplayOrder = this.normalizeOptionalCatalogDisplayOrder(input.publicDisplayOrder);
+        const now = new Date().toISOString();
+        this.db.prepare(`
+            INSERT INTO plan_feature_catalog_overrides (
+                tenant_id,
+                feature_key,
+                label,
+                description,
+                is_custom,
+                public_label,
+                public_description,
+                public_description_visible,
+                public_display_order,
+                created_at,
+                updated_at
+            )
+            VALUES (?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?)
+        `).run(this.tenantId, featureKey, label, description, publicLabel, publicDescription, publicDescriptionVisible === null ? null : (publicDescriptionVisible ? 1 : 0), publicDisplayOrder, now, now);
+        return this.getCustomPlanFeatureCatalogEntry(featureKey) || {
+            featureKey,
+            label,
+            description,
+            isCustom: true,
+            publicLabel,
+            publicDescription,
+            publicDescriptionVisible,
+            publicDisplayOrder,
+            allowedAccessModes: ['enabled', 'disabled'],
+            configTemplate: {}
+        };
+    }
+    deleteCustomPlanFeatureCatalogEntry(featureKeyRaw) {
+        const featureKey = this.canonicalizePlanFeatureKey(featureKeyRaw);
+        if (!featureKey)
+            throw new TaskforceRuleError('featureKey is required', 400, 'FEATURE_KEY_REQUIRED');
+        if (this.isBuiltInPlanFeatureKey(featureKey)) {
+            throw new TaskforceRuleError('Built-in plan features cannot be deleted', 400, 'PLAN_FEATURE_DELETE_BUILTIN_FORBIDDEN');
+        }
+        const existing = this.getCustomPlanFeatureCatalogEntry(featureKey);
+        if (!existing)
+            throw new TaskforceRuleError('Unknown custom plan feature key', 404, 'PLAN_FEATURE_NOT_FOUND');
+        const tx = this.db.transaction(() => {
+            this.db.prepare(`
+                DELETE FROM plan_feature_catalog_overrides
+                WHERE tenant_id = ? AND feature_key = ? AND is_custom = 1
+            `).run(this.tenantId, featureKey);
+            this.db.prepare(`
+                DELETE FROM plan_feature_matrix
+                WHERE tenant_id = ? AND feature_key = ?
+            `).run(this.tenantId, featureKey);
+        });
+        tx();
     }
     updatePlanFeatureCatalogMarketingCopy(input) {
         const featureKey = this.canonicalizePlanFeatureKey(input.featureKey);
         if (!featureKey)
             throw new TaskforceRuleError('featureKey is required', 400, 'FEATURE_KEY_REQUIRED');
         const catalogFeature = DEFAULT_PLAN_FEATURE_CATALOG.find((feature) => feature.featureKey === featureKey);
-        if (!catalogFeature)
+        const customFeature = this.getCustomPlanFeatureCatalogEntry(featureKey);
+        if (!catalogFeature && !customFeature)
             throw new TaskforceRuleError('Unknown plan feature key', 404, 'PLAN_FEATURE_NOT_FOUND');
+        const label = this.normalizeRequiredCatalogLabel(input.label ?? customFeature?.label ?? '');
+        const description = this.normalizeRequiredCatalogLabel(input.description ?? customFeature?.description ?? '');
+        if (customFeature && !label)
+            throw new TaskforceRuleError('Feature label is required', 400, 'PLAN_FEATURE_LABEL_REQUIRED');
         const publicLabel = this.normalizeOptionalCatalogMarketingCopy(input.publicLabel);
         const publicDescription = this.normalizeOptionalCatalogMarketingCopy(input.publicDescription);
+        const publicDescriptionVisible = this.normalizeOptionalCatalogDescriptionVisible(input.publicDescriptionVisible);
         const publicDisplayOrder = this.normalizeOptionalCatalogDisplayOrder(input.publicDisplayOrder);
         const now = new Date().toISOString();
         const tx = this.db.transaction(() => {
-            if (!publicLabel && !publicDescription && publicDisplayOrder === null) {
+            if (!customFeature && !publicLabel && !publicDescription && publicDescriptionVisible === null && publicDisplayOrder === null) {
                 this.db.prepare(`
                     DELETE FROM plan_feature_catalog_overrides
                     WHERE tenant_id = ? AND feature_key = ?
@@ -1525,32 +1700,53 @@ export class PlanEntitlementService {
                 INSERT INTO plan_feature_catalog_overrides (
                     tenant_id,
                     feature_key,
+                    label,
+                    description,
+                    is_custom,
                     public_label,
                     public_description,
+                    public_description_visible,
                     public_display_order,
                     created_at,
                     updated_at
                 )
-                VALUES (?, ?, ?, ?, ?, ?, ?)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT (tenant_id, feature_key) DO UPDATE SET
+                    label = excluded.label,
+                    description = excluded.description,
+                    is_custom = excluded.is_custom,
                     public_label = excluded.public_label,
                     public_description = excluded.public_description,
+                    public_description_visible = excluded.public_description_visible,
                     public_display_order = excluded.public_display_order,
                     updated_at = excluded.updated_at
-            `).run(this.tenantId, featureKey, publicLabel, publicDescription, publicDisplayOrder, now, now);
+            `).run(this.tenantId, featureKey, customFeature ? label : null, customFeature ? description : null, customFeature ? 1 : 0, publicLabel, publicDescription, publicDescriptionVisible === null ? null : (publicDescriptionVisible ? 1 : 0), publicDisplayOrder, now, now);
         });
         tx();
-        return this.listPlanFeatureCatalog().find((feature) => feature.featureKey === featureKey) || {
+        return this.listPlanFeatureCatalog().find((feature) => feature.featureKey === featureKey) || (customFeature ? {
+            featureKey,
+            label,
+            description,
+            isCustom: true,
+            publicLabel,
+            publicDescription,
+            publicDescriptionVisible,
+            publicDisplayOrder,
+            allowedAccessModes: ['enabled', 'disabled'],
+            configTemplate: {}
+        } : {
             featureKey: catalogFeature.featureKey,
             label: catalogFeature.label,
             description: catalogFeature.description,
+            isCustom: false,
             publicLabel,
             publicDescription,
+            publicDescriptionVisible,
             publicDisplayOrder,
             allowedAccessModes: [...catalogFeature.allowedAccessModes],
             configTemplate: { ...catalogFeature.configTemplate },
             ...(catalogFeature.dependsOn?.length ? { dependsOn: [...catalogFeature.dependsOn] } : {})
-        };
+        });
     }
     listPlanVersions(planId) {
         const normalizedPlanId = String(planId || '').trim().toLowerCase();

package/dist/core/PlanFeatureCatalog.test.js

@@ -17,33 +17,40 @@ describe('TaskforceCore plan feature catalog marketing copy', () => {
         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 });
@@ -81,4 +88,52 @@ describe('TaskforceCore plan feature catalog marketing copy', () => {
         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/Taskforce.d.ts

@@ -617,6 +617,8 @@ export interface PlanFeatureCatalogItem {
     featureKey: string;
     label: string;
     description: string;
+    isCustom?: boolean;
+    publicDescriptionVisible?: boolean | null;
     allowedAccessModes: PlanFeatureAccess[];
     configTemplate: Record<string, unknown>;
     dependsOn?: string[];
@@ -1618,10 +1620,22 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     };
     listPlanCatalog(): import("./types.js").PlanCatalogSnapshot[];
     listPlanFeatureCatalog(): import("./types.js").PlanFeatureCatalogItem[];
+    createCustomPlanFeatureCatalogEntry(input: {
+        label: string;
+        description?: string | null;
+        publicLabel?: string | null;
+        publicDescription?: string | null;
+        publicDescriptionVisible?: boolean | null;
+        publicDisplayOrder?: number | null;
+    }): import("./types.js").PlanFeatureCatalogItem;
+    deleteCustomPlanFeatureCatalogEntry(featureKey: string): void;
     updatePlanFeatureCatalogMarketingCopy(input: {
         featureKey: string;
+        label?: string | null;
+        description?: string | null;
         publicLabel?: string | null;
         publicDescription?: string | null;
+        publicDescriptionVisible?: boolean | null;
         publicDisplayOrder?: number | null;
     }): import("./types.js").PlanFeatureCatalogItem;
     listPlanVersions(planId: string): import("./types.js").PlanVersionSnapshot[];

package/dist/core/Taskforce.js

@@ -6219,6 +6219,12 @@ export class TaskforceCore {
     listPlanFeatureCatalog() {
         return this.planEntitlementService.listPlanFeatureCatalog();
     }
+    createCustomPlanFeatureCatalogEntry(input) {
+        return this.planEntitlementService.createCustomPlanFeatureCatalogEntry(input);
+    }
+    deleteCustomPlanFeatureCatalogEntry(featureKey) {
+        return this.planEntitlementService.deleteCustomPlanFeatureCatalogEntry(featureKey);
+    }
     updatePlanFeatureCatalogMarketingCopy(input) {
         return this.planEntitlementService.updatePlanFeatureCatalogMarketingCopy(input);
     }

package/dist/core/types.d.ts

@@ -279,6 +279,7 @@ export interface GlobalTaskforceSettings {
         siteTheme?: 'dark' | 'light';
         pricingPageTitle?: string;
         pricingPageDescription?: string;
+        pricingPageShowPublicDescriptions?: boolean;
     };
     setup?: {
         mode?: 'core' | 'operations';
@@ -509,8 +510,10 @@ export interface PlanFeatureCatalogItem {
     featureKey: string;
     label: string;
     description: string;
+    isCustom?: boolean;
     publicLabel?: string | null;
     publicDescription?: string | null;
+    publicDescriptionVisible?: boolean | null;
     publicDisplayOrder?: number | null;
     allowedAccessModes: PlanFeatureAccess[];
     configTemplate: Record<string, unknown>;

package/dist/migrations/taskSchemaMigrations.js

@@ -476,6 +476,7 @@ export function ensureBillingSchema(db) {
             tenant_id TEXT NOT NULL DEFAULT 'default',
             plan_version_id TEXT NOT NULL,
             billing_interval TEXT NOT NULL,
+            pricing_audience TEXT NOT NULL DEFAULT 'public',
             stripe_price_id TEXT NOT NULL,
             pricing_type TEXT NOT NULL DEFAULT 'stripe',
             active BOOLEAN NOT NULL DEFAULT TRUE,
@@ -483,7 +484,7 @@ export function ensureBillingSchema(db) {
             currency TEXT,
             created_at TEXT NOT NULL,
             updated_at TEXT NOT NULL,
-            PRIMARY KEY (tenant_id, plan_version_id, billing_interval, stripe_price_id)
+            PRIMARY KEY (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id)
         );
 
         CREATE INDEX IF NOT EXISTS idx_user_billing_tenant ON user_billing(tenant_id);
@@ -501,6 +502,7 @@ export function ensureBillingSchema(db) {
     const hasUnitAmountColumn = columns.some((c) => c.name === 'unit_amount');
     const hasCurrencyColumn = columns.some((c) => c.name === 'currency');
     const hasPricingTypeColumn = columns.some((c) => c.name === 'pricing_type');
+    const hasPricingAudienceColumn = columns.some((c) => c.name === 'pricing_audience');
     if (!hasUnitAmountColumn) {
         db.exec(`ALTER TABLE billing_price_mappings ADD COLUMN unit_amount INTEGER`);
     }
@@ -510,30 +512,34 @@ export function ensureBillingSchema(db) {
     if (!hasPricingTypeColumn) {
         db.exec(`ALTER TABLE billing_price_mappings ADD COLUMN pricing_type TEXT NOT NULL DEFAULT 'stripe'`);
     }
+    if (!hasPricingAudienceColumn) {
+        db.exec(`ALTER TABLE billing_price_mappings ADD COLUMN pricing_audience TEXT NOT NULL DEFAULT 'public'`);
+    }
     ensureBillingPriceMappingsConstraints(db);
     normalizeUserBillingDefaults(db);
 }
 function ensureBillingPriceMappingsConstraints(db) {
     if (db.provider === 'postgres') {
         db.exec(`
+            ALTER TABLE billing_price_mappings ADD COLUMN IF NOT EXISTS pricing_audience TEXT NOT NULL DEFAULT 'public';
+            DROP INDEX IF EXISTS idx_billing_price_mappings_active_interval;
             ALTER TABLE billing_price_mappings DROP CONSTRAINT IF EXISTS billing_price_mappings_pkey;
             ALTER TABLE billing_price_mappings
             ADD CONSTRAINT billing_price_mappings_pkey
-            PRIMARY KEY (tenant_id, plan_version_id, billing_interval, stripe_price_id);
+            PRIMARY KEY (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id);
             CREATE UNIQUE INDEX IF NOT EXISTS idx_billing_price_mappings_active_interval
-            ON billing_price_mappings(tenant_id, plan_version_id, billing_interval)
+            ON billing_price_mappings(tenant_id, plan_version_id, billing_interval, pricing_audience)
             WHERE active = TRUE;
         `);
         return;
     }
     const indexes = db.prepare(`PRAGMA index_list(billing_price_mappings)`).all();
     const tableInfo = db.prepare(`PRAGMA table_info(billing_price_mappings)`).all();
-    const hasActiveIntervalIndex = indexes.some((index) => index.name === 'idx_billing_price_mappings_active_interval');
     const primaryKeyColumns = tableInfo
         .filter((column) => Number(column.pk || 0) > 0)
         .sort((a, b) => Number(a.pk || 0) - Number(b.pk || 0))
         .map((column) => String(column.name || ''));
-    const needsPrimaryKeyRepair = primaryKeyColumns.join('|') !== 'tenant_id|plan_version_id|billing_interval|stripe_price_id';
+    const needsPrimaryKeyRepair = primaryKeyColumns.join('|') !== 'tenant_id|plan_version_id|billing_interval|pricing_audience|stripe_price_id';
     if (needsPrimaryKeyRepair) {
         db.exec(`
             ALTER TABLE billing_price_mappings RENAME TO billing_price_mappings_legacy;
@@ -542,6 +548,7 @@ function ensureBillingPriceMappingsConstraints(db) {
                 tenant_id TEXT NOT NULL DEFAULT 'default',
                 plan_version_id TEXT NOT NULL,
                 billing_interval TEXT NOT NULL,
+                pricing_audience TEXT NOT NULL DEFAULT 'public',
                 stripe_price_id TEXT NOT NULL,
                 pricing_type TEXT NOT NULL DEFAULT 'stripe',
                 active BOOLEAN NOT NULL DEFAULT TRUE,
@@ -549,26 +556,25 @@ function ensureBillingPriceMappingsConstraints(db) {
                 currency TEXT,
                 created_at TEXT NOT NULL,
                 updated_at TEXT NOT NULL,
-                PRIMARY KEY (tenant_id, plan_version_id, billing_interval, stripe_price_id)
+                PRIMARY KEY (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id)
             );
 
             INSERT INTO billing_price_mappings (
-                tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
+                tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
             )
             SELECT
-                tenant_id, plan_version_id, billing_interval, stripe_price_id, COALESCE(pricing_type, 'stripe'), active, unit_amount, currency, created_at, updated_at
+                tenant_id, plan_version_id, billing_interval, COALESCE(pricing_audience, 'public'), stripe_price_id, COALESCE(pricing_type, 'stripe'), active, unit_amount, currency, created_at, updated_at
             FROM billing_price_mappings_legacy;
 
             DROP TABLE billing_price_mappings_legacy;
         `);
     }
-    if (!hasActiveIntervalIndex) {
-        db.exec(`
-            CREATE UNIQUE INDEX IF NOT EXISTS idx_billing_price_mappings_active_interval
-            ON billing_price_mappings(tenant_id, plan_version_id, billing_interval)
-            WHERE active = 1;
-        `);
-    }
+    db.exec(`
+        DROP INDEX IF EXISTS idx_billing_price_mappings_active_interval;
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_billing_price_mappings_active_interval
+        ON billing_price_mappings(tenant_id, plan_version_id, billing_interval, pricing_audience)
+        WHERE active = 1;
+    `);
 }
 function normalizeUserBillingDefaults(db) {
     if (db.provider === 'postgres') {
@@ -691,8 +697,12 @@ export function ensureEntitlementsSchema(db) {
         CREATE TABLE IF NOT EXISTS plan_feature_catalog_overrides (
             tenant_id TEXT NOT NULL DEFAULT 'default',
             feature_key TEXT NOT NULL,
+            label TEXT,
+            description TEXT,
+            is_custom INTEGER NOT NULL DEFAULT 0,
             public_label TEXT,
             public_description TEXT,
+            public_description_visible INTEGER,
             public_display_order INTEGER,
             created_at TEXT NOT NULL,
             updated_at TEXT NOT NULL,
@@ -754,6 +764,18 @@ export function ensureEntitlementsSchema(db) {
         db.exec(`ALTER TABLE plan_catalog ADD COLUMN description TEXT`);
     }
     const planFeatureCatalogOverrideColumns = db.prepare(`PRAGMA table_info(plan_feature_catalog_overrides)`).all();
+    if (!planFeatureCatalogOverrideColumns.some((column) => column.name === 'label')) {
+        db.exec(`ALTER TABLE plan_feature_catalog_overrides ADD COLUMN label TEXT`);
+    }
+    if (!planFeatureCatalogOverrideColumns.some((column) => column.name === 'description')) {
+        db.exec(`ALTER TABLE plan_feature_catalog_overrides ADD COLUMN description TEXT`);
+    }
+    if (!planFeatureCatalogOverrideColumns.some((column) => column.name === 'is_custom')) {
+        db.exec(`ALTER TABLE plan_feature_catalog_overrides ADD COLUMN is_custom INTEGER NOT NULL DEFAULT 0`);
+    }
+    if (!planFeatureCatalogOverrideColumns.some((column) => column.name === 'public_description_visible')) {
+        db.exec(`ALTER TABLE plan_feature_catalog_overrides ADD COLUMN public_description_visible INTEGER`);
+    }
     if (!planFeatureCatalogOverrideColumns.some((column) => column.name === 'public_display_order')) {
         db.exec(`ALTER TABLE plan_feature_catalog_overrides ADD COLUMN public_display_order INTEGER`);
     }