@taskforcehq/taskforce 0.3.305 → 0.3.306

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

@@ -141,11 +141,11 @@ describe('TaskforceCore plan version policy', () => {
             const version = core.updatePlanVersionFeatures({
                 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,6 +153,39 @@ describe('TaskforceCore plan version policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    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);

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();
+    });
 });

package/dist/core/SignupMonetizationSettings.test.js

@@ -31,7 +31,7 @@ function openCore(projectRoot) {
     core.updatePlanVersionFeatures({
         planVersionId: 'free-v1',
         features: [
-            { featureKey: 'workspace.switching', access: 'enabled' }
+            { featureKey: 'workspace.workspaces', access: 'enabled' }
         ]
     });
     insertFreePriceMapping(core, 'free-v1');
@@ -44,7 +44,7 @@ describe('TaskforceCore onboarding policy', () => {
         try {
             expect(core.getOnboardingPolicy()).toEqual({
                 mode: 'require_plan_selection',
-                planVersionId: null
+                planId: null
             });
         }
         finally {
@@ -68,13 +68,13 @@ describe('TaskforceCore onboarding policy', () => {
         core.updatePlanVersionFeatures({
             planVersionId: 'free-v1',
             features: [
-                { featureKey: 'workspace.switching', access: 'enabled' }
+                { featureKey: 'workspace.workspaces', access: 'enabled' }
             ]
         });
         try {
             expect(core.getOnboardingPolicy()).toEqual({
                 mode: 'require_plan_selection',
-                planVersionId: null
+                planId: null
             });
         }
         finally {
@@ -82,16 +82,16 @@ describe('TaskforceCore onboarding policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('fails validation for auto_grant_free without a plan version id', () => {
+    it('fails validation for auto_grant_free without a plan id', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
             expect(core.validateOnboardingPolicy({
                 mode: 'auto_grant_free',
-                planVersionId: null
+                planId: null
             })).toEqual(expect.objectContaining({
                 valid: false,
-                code: 'ONBOARDING_PLAN_VERSION_REQUIRED'
+                code: 'ONBOARDING_PLAN_REQUIRED'
             }));
         }
         finally {
@@ -99,16 +99,16 @@ describe('TaskforceCore onboarding policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('fails validation when the configured version does not exist', () => {
+    it('fails validation when the configured plan does not exist', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
             expect(core.validateOnboardingPolicy({
                 mode: 'auto_grant_free',
-                planVersionId: 'missing-v9'
+                planId: 'missing'
             })).toEqual(expect.objectContaining({
                 valid: false,
-                code: 'ONBOARDING_PLAN_VERSION_NOT_FOUND'
+                code: 'ONBOARDING_PLAN_NOT_FOUND'
             }));
         }
         finally {
@@ -116,14 +116,14 @@ describe('TaskforceCore onboarding policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('fails validation when the configured version belongs to a disabled plan', () => {
+    it('fails validation when the configured plan is disabled', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
             core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'archived' });
             expect(core.validateOnboardingPolicy({
                 mode: 'auto_grant_free',
-                planVersionId: 'free-v1'
+                planId: 'free'
             })).toEqual(expect.objectContaining({
                 valid: false,
                 code: 'ONBOARDING_PLAN_NOT_ENABLED'
@@ -134,14 +134,14 @@ describe('TaskforceCore onboarding policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('fails validation when auto_grant_free points at a version without free pricing', () => {
+    it('fails validation when auto_grant_free points at a plan whose default version lacks free pricing', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
             core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
             expect(core.validateOnboardingPolicy({
                 mode: 'auto_grant_free',
-                planVersionId: 'team-5-v1'
+                planId: 'team-5'
             })).toEqual(expect.objectContaining({
                 valid: false,
                 code: 'ONBOARDING_PLAN_MUST_BE_FREE'
@@ -152,13 +152,13 @@ describe('TaskforceCore onboarding policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('passes validation for require_plan_selection without a plan version id', () => {
+    it('passes validation for require_plan_selection without a plan id', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
             expect(core.validateOnboardingPolicy({
                 mode: 'require_plan_selection',
-                planVersionId: null
+                planId: null
             })).toEqual({ valid: true });
         }
         finally {
@@ -172,7 +172,7 @@ describe('TaskforceCore onboarding policy', () => {
         try {
             const created = core.registerPasswordUser({
                 email: 'implicit-onboarding@example.com',
-                password: 'password123'
+                password: 'ValidPassphrase123!'
             });
             expect(created.planSelectionRequired).toBe(true);
             expect(created.checkoutPending).toBe(false);
@@ -201,15 +201,15 @@ describe('TaskforceCore onboarding policy', () => {
                 billing: {
                     onboardingPolicy: {
                         mode: 'require_plan_selection',
-                        planVersionId: null
+                        planId: null
                     }
                 }
             });
             const db = core.getDatabaseAdapter();
             db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, auth_provider, external_auth_id, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)
-            `).run('pending-u1', tenantId, 'pending@example.com', 'Pending', 'token', 'pending-u1', now, now);
+                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
+                VALUES (?, ?, ?, ?, 0, ?, ?)
+            `).run('pending-u1', tenantId, 'pending@example.com', 'Pending', now, now);
             db.prepare(`
                 INSERT INTO user_billing (user_id, tenant_id, entitlement_state, created_at, updated_at)
                 VALUES (?, ?, ?, ?, ?)
@@ -248,9 +248,9 @@ describe('TaskforceCore onboarding policy', () => {
             core.upsertPlanCatalog({ planId: 'basic', displayName: 'Basic', status: 'active' });
             const db = core.getDatabaseAdapter();
             db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, auth_provider, external_auth_id, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)
-            `).run('checkout-u1', tenantId, 'checkout@example.com', 'Checkout', 'token', 'checkout-u1', now, now);
+                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
+                VALUES (?, ?, ?, ?, 0, ?, ?)
+            `).run('checkout-u1', tenantId, 'checkout@example.com', 'Checkout', now, now);
             core.transitionCanonicalCommercialState({
                 accountId: 'checkout-u1',
                 planVersionId: 'basic-v1',
@@ -286,9 +286,9 @@ describe('TaskforceCore onboarding policy', () => {
             core.upsertPlanCatalog({ planId: 'basic', displayName: 'Basic', status: 'active' });
             const db = core.getDatabaseAdapter();
             db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, auth_provider, external_auth_id, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)
-            `).run('expired-checkout-u1', tenantId, 'expired@example.com', 'Expired Checkout', 'token', 'expired-checkout-u1', now, now);
+                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
+                VALUES (?, ?, ?, ?, 0, ?, ?)
+            `).run('expired-checkout-u1', tenantId, 'expired@example.com', 'Expired Checkout', now, now);
             core.transitionCanonicalCommercialState({
                 accountId: 'expired-checkout-u1',
                 planVersionId: 'basic-v1',
@@ -340,4 +340,176 @@ describe('TaskforceCore onboarding policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('treats an expired trialing entitlement as requiring plan reselection', () => {
+        const projectRoot = makeProjectRoot();
+        const tenantId = path.basename(projectRoot);
+        const core = openCore(projectRoot);
+        try {
+            const now = new Date().toISOString();
+            const expiredAt = new Date(Date.now() - (60 * 1000)).toISOString();
+            core.upsertPlanCatalog({ planId: 'basic', displayName: 'Basic', status: 'active' });
+            const db = core.getDatabaseAdapter();
+            db.prepare(`
+                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
+                VALUES (?, ?, ?, ?, 0, ?, ?)
+            `).run('expired-trial-u1', tenantId, 'expired-trial@example.com', 'Expired Trial', now, now);
+            core.transitionCanonicalCommercialState({
+                accountId: 'expired-trial-u1',
+                planVersionId: 'basic-v1',
+                state: 'trialing',
+                source: 'system',
+                updatedBy: 'trial-start',
+                billingMirrorPlanId: 'basic',
+                effectiveAt: now,
+                effectiveUntil: expiredAt,
+                createdAt: now,
+                updatedAt: now
+            });
+            expect(core.getAccountAccessStatus('expired-trial-u1')).toEqual(expect.objectContaining({
+                gate: 'plan_selection_required',
+                canAccessApp: false,
+                canAccessPlans: true,
+                planSelectionRequired: true,
+                message: 'Choose a plan to continue.'
+            }));
+            expect(core.getAccountEntitlement('expired-trial-u1')).toEqual(expect.objectContaining({
+                state: 'pending_plan_selection',
+                effectiveUntil: null
+            }));
+            const entitlementRow = db.prepare(`
+                SELECT entitlement_state, effective_until, updated_by
+                FROM account_entitlements
+                WHERE tenant_id = ? AND account_id = ?
+                LIMIT 1
+            `).get(tenantId, 'expired-trial-u1');
+            expect(entitlementRow).toEqual(expect.objectContaining({
+                entitlement_state: 'pending_plan_selection',
+                effective_until: null,
+                updated_by: 'trial-expired'
+            }));
+            const billingRow = db.prepare(`
+                SELECT entitlement_state, tier, effective_until
+                FROM user_billing
+                WHERE tenant_id = ? AND user_id = ?
+                LIMIT 1
+            `).get(tenantId, 'expired-trial-u1');
+            expect(billingRow).toEqual(expect.objectContaining({
+                entitlement_state: 'pending_plan_selection',
+                tier: '',
+                effective_until: null
+            }));
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('auto-heals a pending-plan-selection entitlement from an active Stripe billing mirror', () => {
+        const projectRoot = makeProjectRoot();
+        const tenantId = path.basename(projectRoot);
+        const core = openCore(projectRoot);
+        try {
+            const now = new Date().toISOString();
+            const nextRenewal = new Date(Date.now() + (24 * 60 * 60 * 1000)).toISOString();
+            core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
+            const db = core.getDatabaseAdapter();
+            db.prepare(`
+                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
+                VALUES (?, ?, ?, ?, 0, ?, ?)
+            `).run('mirror-heal-u1', tenantId, 'mirror-heal@example.com', 'Mirror Heal', now, now);
+            core.transitionCanonicalCommercialState({
+                accountId: 'mirror-heal-u1',
+                planVersionId: 'free-v1',
+                state: 'pending_plan_selection',
+                source: 'backfill',
+                updatedBy: 'backfill',
+                billingMirrorPlanId: null,
+                effectiveAt: now,
+                createdAt: now,
+                updatedAt: now
+            });
+            db.prepare(`
+                UPDATE user_billing
+                SET stripe_customer_id = ?, stripe_subscription_id = ?, entitlement_state = ?, tier = ?, effective_until = ?, updated_at = ?
+                WHERE tenant_id = ? AND user_id = ?
+            `).run('cus_heal', 'sub_heal', 'active', 'team-5', nextRenewal, now, tenantId, 'mirror-heal-u1');
+            expect(core.getAccountAccessStatus('mirror-heal-u1')).toEqual(expect.objectContaining({
+                gate: 'ok',
+                canAccessApp: true,
+                planSelectionRequired: false
+            }));
+            expect(core.getAccountEntitlement('mirror-heal-u1')).toEqual(expect.objectContaining({
+                state: 'active',
+                planId: 'team-5',
+                planVersionId: 'team-5-v1',
+                effectiveUntil: nextRenewal
+            }));
+            const entitlementRow = db.prepare(`
+                SELECT entitlement_state, plan_version_id, effective_until, updated_by
+                FROM account_entitlements
+                WHERE tenant_id = ? AND account_id = ?
+                LIMIT 1
+            `).get(tenantId, 'mirror-heal-u1');
+            expect(entitlementRow).toEqual(expect.objectContaining({
+                entitlement_state: 'active',
+                plan_version_id: 'team-5-v1',
+                effective_until: nextRenewal,
+                updated_by: 'billing-mirror-auto-heal'
+            }));
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('auto-heals a pending-plan-selection entitlement from Stripe status and price mapping when mirror state is stale', () => {
+        const projectRoot = makeProjectRoot();
+        const tenantId = path.basename(projectRoot);
+        const core = openCore(projectRoot);
+        try {
+            const now = new Date().toISOString();
+            const nextRenewal = new Date(Date.now() + (24 * 60 * 60 * 1000)).toISOString();
+            core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
+            const db = core.getDatabaseAdapter();
+            db.prepare(`
+                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
+                VALUES (?, ?, ?, ?, 0, ?, ?)
+            `).run('mirror-price-heal-u1', tenantId, 'mirror-price-heal@example.com', 'Mirror Price Heal', now, now);
+            core.transitionCanonicalCommercialState({
+                accountId: 'mirror-price-heal-u1',
+                planVersionId: 'free-v1',
+                state: 'pending_plan_selection',
+                source: 'backfill',
+                updatedBy: 'checkout-expired',
+                billingMirrorPlanId: null,
+                effectiveAt: now,
+                createdAt: now,
+                updatedAt: now
+            });
+            db.prepare(`
+                UPDATE user_billing
+                SET stripe_customer_id = ?, stripe_subscription_id = ?, stripe_price_id = ?, stripe_status = ?, entitlement_state = ?, tier = ?, effective_until = ?, updated_at = ?
+                WHERE tenant_id = ? AND user_id = ?
+            `).run('cus_heal_2', 'sub_heal_2', 'price_team_5_month', 'active', 'pending_plan_selection', 'team-5', nextRenewal, now, tenantId, 'mirror-price-heal-u1');
+            db.prepare(`
+                INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, stripe_price_id, active, created_at, updated_at)
+                VALUES (?, ?, ?, ?, 1, ?, ?)
+            `).run(tenantId, 'team-5-v1', 'month', 'price_team_5_month', now, now);
+            expect(core.getAccountAccessStatus('mirror-price-heal-u1')).toEqual(expect.objectContaining({
+                gate: 'ok',
+                canAccessApp: true,
+                planSelectionRequired: false
+            }));
+            expect(core.getAccountEntitlement('mirror-price-heal-u1')).toEqual(expect.objectContaining({
+                state: 'active',
+                planId: 'team-5',
+                planVersionId: 'team-5-v1',
+                effectiveUntil: nextRenewal
+            }));
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
 });

package/dist/core/SyncReconciliationService.js

@@ -1,4 +1,5 @@
 import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
+import { buildTaskSyncChangeKey } from '../sync/taskSyncChangeKey.js';
 export function listTasksForSyncService(deps, workspaceId, cursor, limit) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
     const safeLimit = Math.max(1, Math.min(10000, Math.floor(limit)));
@@ -67,72 +68,8 @@ export function listWorkspaceSyncDeletesSinceService(deps, workspaceId, cursor,
     }))
         .filter((row) => row.taskId.length > 0 && Number.isFinite(Date.parse(row.deletedAt)));
 }
-function normalizeConflictTaxonomies(value) {
-    if (!value || typeof value !== 'object')
-        return {};
-    const source = value;
-    return Object.keys(source).sort().reduce((acc, key) => {
-        const raw = source[key];
-        if (Array.isArray(raw)) {
-            acc[key] = raw.map((entry) => String(entry ?? '')).sort();
-        }
-        else if (raw === null || raw === undefined) {
-            acc[key] = '';
-        }
-        else {
-            acc[key] = String(raw);
-        }
-        return acc;
-    }, {});
-}
-function normalizeConflictChecklistItems(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value
-        .map((item) => {
-        const entry = item && typeof item === 'object' ? item : {};
-        return {
-            id: String(entry.id || '').trim(),
-            title: String(entry.title || '').trim(),
-            isCompleted: Boolean(entry.isCompleted),
-            order: entry.order === undefined || entry.order === null ? '' : String(entry.order),
-        };
-    })
-        .sort((left, right) => {
-        const leftOrder = Number.parseInt(left.order, 10);
-        const rightOrder = Number.parseInt(right.order, 10);
-        if (Number.isFinite(leftOrder) && Number.isFinite(rightOrder) && leftOrder !== rightOrder) {
-            return leftOrder - rightOrder;
-        }
-        if (left.title !== right.title)
-            return left.title.localeCompare(right.title);
-        return left.id.localeCompare(right.id);
-    });
-}
 function buildSyncConflictKey(task, archivedValue) {
-    const source = task || {};
-    return JSON.stringify({
-        id: String(source.id || ''),
-        title: String(source.title || ''),
-        description: source.description === null || source.description === undefined ? '' : String(source.description),
-        category: String(source.category || ''),
-        type: String(source.type || ''),
-        priority: source.priority === undefined || source.priority === null ? '' : String(source.priority),
-        complexity: source.complexity === undefined || source.complexity === null ? '' : String(source.complexity),
-        status: String(source.status || ''),
-        approach: source.approach === undefined || source.approach === null ? '' : String(source.approach),
-        canceledReason: source.canceledReason === undefined || source.canceledReason === null ? '' : String(source.canceledReason),
-        scheduledDate: source.scheduledDate === undefined || source.scheduledDate === null ? '' : String(source.scheduledDate),
-        dueDate: source.dueDate === undefined || source.dueDate === null ? '' : String(source.dueDate),
-        scheduledWeekKey: source.scheduledWeekKey === undefined || source.scheduledWeekKey === null ? '' : String(source.scheduledWeekKey),
-        orderInDay: source.orderInDay === undefined || source.orderInDay === null ? '' : String(source.orderInDay),
-        workstreamId: source.workstreamId === undefined || source.workstreamId === null ? '' : String(source.workstreamId),
-        referenceNumber: source.referenceNumber === undefined || source.referenceNumber === null ? '' : String(source.referenceNumber),
-        assignee: source.assignee === undefined || source.assignee === null ? '' : String(source.assignee),
-        taxonomies: normalizeConflictTaxonomies(source.taxonomies),
-        checklistItems: normalizeConflictChecklistItems(source.checklistItems),
-        isArchived: archivedValue ? '1' : '0'
-    });
+    return buildTaskSyncChangeKey(task, archivedValue);
 }
 export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);