@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/core/SignupMonetizationSettings.test.js

@@ -4,7 +4,17 @@ import os from 'os';
 import path from 'path';
 import { TaskforceCore } from './Taskforce';
 function makeProjectRoot() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-signup-monetization-'));
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-onboarding-policy-'));
+}
+function insertFreePriceMapping(core, planVersionId) {
+    const db = core.db;
+    const tenantId = core.getTenantId();
+    const now = new Date().toISOString();
+    db.prepare(`
+        INSERT OR IGNORE INTO billing_price_mappings (
+            tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(tenantId, planVersionId, 'month', `free:${planVersionId}:month`, 'free', 1, 0, null, now, now);
 }
 function openCore(projectRoot) {
     const core = new TaskforceCore({
@@ -12,31 +22,24 @@ function openCore(projectRoot) {
         storagePath: path.join(projectRoot, '.taskforce'),
         tenantId: path.basename(projectRoot)
     });
-    const db = core.db;
-    const now = new Date().toISOString();
     core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter' });
-    db.prepare(`
-        INSERT OR IGNORE INTO billing_price_mappings (
-            tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(path.basename(projectRoot), 'starter-v1', 'month', 'free:starter-v1:month', 'free', 1, 0, null, now, now);
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'active' });
     core.updatePlanVersionFeatures({
         planVersionId: 'starter-v1',
         features: [
             { featureKey: 'workspace.switching', access: 'enabled' }
         ]
     });
+    insertFreePriceMapping(core, 'starter-v1');
     return core;
 }
-describe('TaskforceCore signup monetization settings', () => {
-    it('normalizes defaults to auto_assign_default with no version id', () => {
+describe('TaskforceCore onboarding policy', () => {
+    it('defaults to require_plan_selection with no plan version', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
-            expect(core.getSignupMonetizationSettings()).toEqual({
-                strategy: 'auto_assign_default',
-                defaultSignupPlanVersionId: null
+            expect(core.getOnboardingPolicy()).toEqual({
+                mode: 'require_plan_selection',
+                planVersionId: null
             });
         }
         finally {
@@ -44,16 +47,16 @@ describe('TaskforceCore signup monetization settings', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('fails validation for auto_assign_default without a default version id', () => {
+    it('fails validation for auto_grant_free without a plan version id', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
-            expect(core.validateSignupMonetizationSettings({
-                strategy: 'auto_assign_default',
-                defaultSignupPlanVersionId: null
+            expect(core.validateOnboardingPolicy({
+                mode: 'auto_grant_free',
+                planVersionId: null
             })).toEqual(expect.objectContaining({
                 valid: false,
-                code: 'SIGNUP_PLAN_VERSION_REQUIRED'
+                code: 'ONBOARDING_PLAN_VERSION_REQUIRED'
             }));
         }
         finally {
@@ -65,12 +68,12 @@ describe('TaskforceCore signup monetization settings', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
-            expect(core.validateSignupMonetizationSettings({
-                strategy: 'auto_assign_default',
-                defaultSignupPlanVersionId: 'missing-v9'
+            expect(core.validateOnboardingPolicy({
+                mode: 'auto_grant_free',
+                planVersionId: 'missing-v9'
             })).toEqual(expect.objectContaining({
                 valid: false,
-                code: 'SIGNUP_PLAN_VERSION_NOT_FOUND'
+                code: 'ONBOARDING_PLAN_VERSION_NOT_FOUND'
             }));
         }
         finally {
@@ -83,12 +86,12 @@ describe('TaskforceCore signup monetization settings', () => {
         const core = openCore(projectRoot);
         try {
             core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'archived' });
-            expect(core.validateSignupMonetizationSettings({
-                strategy: 'auto_assign_default',
-                defaultSignupPlanVersionId: 'starter-v1'
+            expect(core.validateOnboardingPolicy({
+                mode: 'auto_grant_free',
+                planVersionId: 'starter-v1'
             })).toEqual(expect.objectContaining({
                 valid: false,
-                code: 'SIGNUP_PLAN_NOT_ENABLED'
+                code: 'ONBOARDING_PLAN_NOT_ENABLED'
             }));
         }
         finally {
@@ -96,13 +99,31 @@ describe('TaskforceCore signup monetization settings', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('passes validation for plan_selection_required without a default version id', () => {
+    it('fails validation when auto_grant_free points at a version without free pricing', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);
         try {
-            expect(core.validateSignupMonetizationSettings({
-                strategy: 'plan_selection_required',
-                defaultSignupPlanVersionId: null
+            core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab', status: 'active' });
+            expect(core.validateOnboardingPolicy({
+                mode: 'auto_grant_free',
+                planVersionId: 'collab-v1'
+            })).toEqual(expect.objectContaining({
+                valid: false,
+                code: 'ONBOARDING_PLAN_MUST_BE_FREE'
+            }));
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('passes validation for require_plan_selection without a plan version id', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            expect(core.validateOnboardingPolicy({
+                mode: 'require_plan_selection',
+                planVersionId: null
             })).toEqual({ valid: true });
         }
         finally {
@@ -110,19 +131,21 @@ describe('TaskforceCore signup monetization settings', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('does not backfill canonical entitlements for pending plan selection accounts', () => {
+    it('allows backfill transitions to create pending plan selection entitlements', () => {
         const projectRoot = makeProjectRoot();
         const tenantId = path.basename(projectRoot);
-        const initial = openCore(projectRoot);
+        const core = openCore(projectRoot);
         try {
             const now = new Date().toISOString();
-            initial.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'plan_selection_required',
-                    defaultSignupPlanVersionId: null
+            core.updateGlobalSettings({
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'require_plan_selection',
+                        planVersionId: null
+                    }
                 }
             });
-            const db = initial.getDatabaseAdapter();
+            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, ?, ?)
@@ -131,28 +154,129 @@ describe('TaskforceCore signup monetization settings', () => {
                 INSERT INTO user_billing (user_id, tenant_id, entitlement_state, created_at, updated_at)
                 VALUES (?, ?, ?, ?, ?)
             `).run('pending-u1', tenantId, 'pending_plan_selection', now, now);
+            core.transitionCanonicalCommercialState({
+                accountId: 'pending-u1',
+                planVersionId: 'starter-v1',
+                state: 'pending_plan_selection',
+                source: 'backfill',
+                updatedBy: 'backfill',
+                billingMirrorPlanId: null,
+                effectiveAt: now,
+                createdAt: now,
+                updatedAt: now
+            });
+            expect(core.hasAccountEntitlement('pending-u1')).toBe(true);
+            expect(core.getAccountAccessStatus('pending-u1')).toEqual(expect.objectContaining({
+                gate: 'plan_selection_required',
+                canAccessApp: false,
+                canAccessPlans: true,
+                planSelectionRequired: true
+            }));
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('treats a live checkout_pending entitlement as checkout recovery state', () => {
+        const projectRoot = makeProjectRoot();
+        const tenantId = path.basename(projectRoot);
+        const core = openCore(projectRoot);
+        try {
+            const now = new Date().toISOString();
+            const checkoutExpiresAt = new Date(Date.now() + (60 * 60 * 1000)).toISOString();
+            core.upsertPlanCatalog({ planId: 'pro', displayName: 'Pro', 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);
+            core.transitionCanonicalCommercialState({
+                accountId: 'checkout-u1',
+                planVersionId: 'pro-v1',
+                state: 'checkout_pending',
+                source: 'checkout-start',
+                updatedBy: 'checkout-start',
+                billingMirrorPlanId: 'pro',
+                effectiveAt: now,
+                effectiveUntil: checkoutExpiresAt,
+                createdAt: now,
+                updatedAt: now
+            });
+            expect(core.getAccountAccessStatus('checkout-u1')).toEqual(expect.objectContaining({
+                gate: 'checkout_pending',
+                canAccessApp: false,
+                canAccessPlans: true,
+                planSelectionRequired: false,
+                message: 'Complete checkout to continue.'
+            }));
         }
         finally {
-            initial.close();
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
         }
-        const reopened = openCore(projectRoot);
+    });
+    it('treats an expired checkout_pending entitlement as requiring plan reselection', () => {
+        const projectRoot = makeProjectRoot();
+        const tenantId = path.basename(projectRoot);
+        const core = openCore(projectRoot);
         try {
-            reopened.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'plan_selection_required',
-                    defaultSignupPlanVersionId: null
-                }
+            const now = new Date().toISOString();
+            const expiredAt = new Date(Date.now() - (60 * 1000)).toISOString();
+            core.upsertPlanCatalog({ planId: 'pro', displayName: 'Pro', 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);
+            core.transitionCanonicalCommercialState({
+                accountId: 'expired-checkout-u1',
+                planVersionId: 'pro-v1',
+                state: 'checkout_pending',
+                source: 'checkout-start',
+                updatedBy: 'checkout-start',
+                billingMirrorPlanId: 'pro',
+                effectiveAt: now,
+                effectiveUntil: expiredAt,
+                createdAt: now,
+                updatedAt: now
             });
-            expect(reopened.hasAccountEntitlement('pending-u1')).toBe(false);
-            expect(reopened.getAccountAccessStatus('pending-u1')).toEqual(expect.objectContaining({
+            expect(core.getAccountAccessStatus('expired-checkout-u1')).toEqual(expect.objectContaining({
                 gate: 'plan_selection_required',
                 canAccessApp: false,
                 canAccessPlans: true,
-                planSelectionRequired: true
+                planSelectionRequired: true,
+                message: 'Choose a plan to continue.'
+            }));
+            expect(core.getAccountEntitlement('expired-checkout-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-checkout-u1');
+            expect(entitlementRow).toEqual(expect.objectContaining({
+                entitlement_state: 'pending_plan_selection',
+                effective_until: null,
+                updated_by: 'checkout-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-checkout-u1');
+            expect(billingRow).toEqual(expect.objectContaining({
+                entitlement_state: 'pending_plan_selection',
+                tier: '',
+                effective_until: null
             }));
         }
         finally {
-            reopened.close();
+            core.close();
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });

package/dist/core/SyncReconciliationService.d.ts

@@ -21,6 +21,7 @@ export interface SyncReconciliationServiceDeps {
         persistBackup?: boolean;
         workspaceId?: string;
         allowClientProvidedId?: boolean;
+        preferIncomingReferenceNumberOnConflict?: boolean;
         skipRecompute?: boolean;
         syncUpdatedAt?: string;
         actorRef?: string;
@@ -28,6 +29,7 @@ export interface SyncReconciliationServiceDeps {
     }) => TaskItem;
     updateTask: (id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        preferIncomingReferenceNumberOnConflict?: boolean;
         skipRecompute?: boolean;
         syncUpdatedAt?: string;
         actorRef?: string;

package/dist/core/SyncReconciliationService.js

@@ -198,6 +198,7 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
             createdBy: sourceTask.createdBy === undefined ? existing?.createdBy : sourceTask.createdBy,
             assignee: sourceTask.assignee === undefined ? existing?.assignee : sourceTask.assignee,
             referenceNumber: sourceTask.referenceNumber === undefined ? existing?.referenceNumber : sourceTask.referenceNumber,
+            localReferenceNumber: sourceTask.referenceNumber === undefined ? existing?.localReferenceNumber : null,
             scheduledDate: sourceTask.scheduledDate === undefined ? existing?.scheduledDate : sourceTask.scheduledDate,
             dueDate: sourceTask.dueDate === undefined ? existing?.dueDate : sourceTask.dueDate,
             scheduledWeekKey: sourceTask.scheduledWeekKey === undefined ? existing?.scheduledWeekKey : sourceTask.scheduledWeekKey,
@@ -228,6 +229,7 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
                     persistBackup: false,
                     workspaceId: normalizedWorkspaceId,
                     allowClientProvidedId: true,
+                    preferIncomingReferenceNumberOnConflict: true,
                     skipRecompute: true,
                     syncUpdatedAt: incomingUpdatedAt,
                     skipTaskEvents: true
@@ -244,6 +246,7 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
             try {
                 updatedTask = deps.updateTask(taskId, taskPatch, normalizedWorkspaceId, {
                     persistBackup: false,
+                    preferIncomingReferenceNumberOnConflict: true,
                     skipRecompute: true,
                     syncUpdatedAt: incomingUpdatedAt,
                     skipTaskEvents: true