@taskforcehq/taskforce 0.3.304 → 0.3.306

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

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

package/dist/core/PlanFeatureCatalog.test.js

@@ -0,0 +1,84 @@
+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?.publicDisplayOrder).toBe(20);
+        const updated = core.updatePlanFeatureCatalogMarketingCopy({
+            featureKey: 'collaboration.ai_profiles',
+            publicLabel: 'AI teammates',
+            publicDescription: 'Add reusable AI teammates to your workspace.',
+            publicDisplayOrder: 24
+        });
+        expect(updated.publicLabel).toBe('AI teammates');
+        expect(updated.publicDescription).toBe('Add reusable AI teammates to your workspace.');
+        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?.publicDisplayOrder).toBe(24);
+        const cleared = core.updatePlanFeatureCatalogMarketingCopy({
+            featureKey: 'collaboration.ai_profiles',
+            publicLabel: '   ',
+            publicDescription: '',
+            publicDisplayOrder: null
+        });
+        expect(cleared.publicLabel ?? null).toBeNull();
+        expect(cleared.publicDescription ?? 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?.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 });
+    });
+});

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,13 +139,13 @@ 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: 'workspace.workspaces', access: 'limited', config: { maxWorkspaces: 0 } },
                     { featureKey: 'context.uploads', access: 'limited', config: { storageLimitMb: -50 } }
                 ]
             });
-            expect(version.features['workspace.switching']?.config).toEqual({ maxWorkspaces: 1 });
+            expect(version.features['workspace.workspaces']?.config).toEqual({ maxWorkspaces: 1 });
             expect(version.features['context.uploads']?.config).toEqual({ storageLimitMb: 1 });
         }
         finally {
@@ -153,22 +153,48 @@ describe('TaskforceCore plan version policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('starts new plans disabled and rejects enabling plans without pricing', () => {
+    it('migrates legacy workspace feature keys to the canonical key', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.updatePlanVersionFeatures({
+                planVersionId: 'free-v1',
+                features: [
+                    { featureKey: 'workspace.workspaces', access: 'limited', config: { maxWorkspaces: 1 } }
+                ]
+            });
+            const db = core.db;
+            db.prepare(`
+                UPDATE plan_feature_matrix
+                SET feature_key = 'workspace.switching'
+                WHERE tenant_id = ? AND plan_version_id = ? AND feature_key = 'workspace.workspaces'
+            `).run('default', 'free-v1');
+            core.planEntitlementService.normalizeLegacyPlanDataIfNeeded();
+            const version = core.getPlanVersionFeatures('free', 'free-v1');
+            expect(version.features['workspace.workspaces']).toBeTruthy();
+            expect(version.features['workspace.switching']).toBeUndefined();
+            const rows = db.prepare(`
+                SELECT feature_key
+                FROM plan_feature_matrix
+                WHERE tenant_id = ? AND plan_version_id = ?
+            `).all('default', 'free-v1');
+            expect(rows.some((row) => row.feature_key === 'workspace.switching')).toBe(false);
+            expect(rows.some((row) => row.feature_key === 'workspace.workspaces')).toBe(true);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    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();

package/dist/core/PlanningEntities.test.js

@@ -92,4 +92,56 @@ describe('TaskforceCore planning entity persistence', () => {
         expect(clearedTask?.workstreamId).toBeNull();
         core.close();
     });
+    it('builds lightweight planning bootstrap summaries without hydrating full task details', () => {
+        const core = createCore();
+        const initiative = core.createInitiative({ title: 'Launch initiative' });
+        const deliveryWorkstream = core.createWorkstream({
+            title: 'Delivery',
+            initiativeId: initiative.id,
+        });
+        const billingWorkstream = core.createWorkstream({
+            title: 'Billing',
+            initiativeId: initiative.id,
+        });
+        core.createTask({
+            title: 'Ship onboarding copy',
+            workstreamId: deliveryWorkstream.id,
+            status: 'task',
+        });
+        core.createTask({
+            title: 'Review launch checklist',
+            workstreamId: deliveryWorkstream.id,
+            status: 'done',
+        });
+        core.createTask({
+            title: 'Update billing note',
+            workstreamId: billingWorkstream.id,
+            status: 'cancelled',
+        });
+        core.createTask({
+            title: 'Unlinked task',
+            status: 'task',
+        });
+        const bootstrap = core.listPlanningBootstrap();
+        const deliverySummary = bootstrap.workstreamTaskSummaries.find((entry) => entry.workstreamId === deliveryWorkstream.id);
+        const billingSummary = bootstrap.workstreamTaskSummaries.find((entry) => entry.workstreamId === billingWorkstream.id);
+        expect(bootstrap.initiatives.map((entry) => entry.id)).toEqual([initiative.id]);
+        expect(bootstrap.workstreams.map((entry) => entry.id)).toEqual([deliveryWorkstream.id, billingWorkstream.id]);
+        expect(deliverySummary).toMatchObject({
+            workstreamId: deliveryWorkstream.id,
+            taskCount: 2,
+            completedTaskCount: 1,
+        });
+        expect(deliverySummary?.tasks).toEqual(expect.arrayContaining([
+            expect.objectContaining({ title: 'Ship onboarding copy', status: 'task' }),
+            expect.objectContaining({ title: 'Review launch checklist', status: 'done' }),
+        ]));
+        expect(billingSummary).toMatchObject({
+            workstreamId: billingWorkstream.id,
+            taskCount: 1,
+            completedTaskCount: 1,
+        });
+        expect(bootstrap.workstreamTaskSummaries.some((entry) => entry.tasks.some((task) => task.title === 'Unlinked task'))).toBe(false);
+        core.close();
+    });
 });