@taskforcehq/taskforce 0.3.302 → 0.3.304

package/dist/core/SystemAdmin.test.js

@@ -6,7 +6,16 @@ import { TaskforceCore } from './Taskforce';
 function makeProjectRoot() {
     return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-system-admin-'));
 }
-function seedPlans(core) {
+function insertFreePriceMapping(core, planVersionId) {
+    const db = core.db;
+    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(core.getTenantId(), planVersionId, 'month', `free:${planVersionId}:month`, 'free', 1, 0, null, now, now);
+}
+function seedPlanCatalog(core) {
     core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'active' });
     core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab', status: 'active' });
     core.updatePlanVersion({
@@ -29,10 +38,16 @@ function seedPlans(core) {
             { featureKey: 'workspace.switching', access: 'enabled' }
         ]
     });
+    insertFreePriceMapping(core, 'starter-v1');
+}
+function seedPlans(core) {
+    seedPlanCatalog(core);
     core.updateGlobalSettings({
-        auth: {
-            signupMonetizationStrategy: 'auto_assign_default',
-            defaultSignupPlanVersionId: 'starter-v1'
+        billing: {
+            onboardingPolicy: {
+                mode: 'auto_grant_free',
+                planVersionId: 'starter-v1'
+            }
         }
     });
 }
@@ -98,7 +113,7 @@ describe('TaskforceCore system admin model', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('uses configured signup default plan version for registration when auto-assign config is valid', () => {
+    it('starts a configured onboarding trial when the onboarding policy is trial-based', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
@@ -106,7 +121,8 @@ describe('TaskforceCore system admin model', () => {
                 planId: 'collab',
                 versionNumber: 2,
                 isDefault: true,
-                seatLimit: 10
+                seatLimit: 10,
+                trialDays: 14
             });
             core.updatePlanVersionFeatures({
                 planVersionId: 'collab-v2',
@@ -124,9 +140,11 @@ describe('TaskforceCore system admin model', () => {
                 seatLimit: null
             });
             core.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'auto_assign_default',
-                    defaultSignupPlanVersionId: 'collab-v2'
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'auto_start_trial',
+                        planVersionId: 'collab-v2'
+                    }
                 }
             });
             const created = core.registerPasswordUser({
@@ -143,22 +161,25 @@ describe('TaskforceCore system admin model', () => {
             `).get(core.getTenantId(), created.userId);
             expect(entitlement.planVersionId).toBe('collab-v2');
             expect(entitlement.planId).toBe('collab');
+            expect(entitlement.state).toBe('trialing');
             expect(billing?.tier).toBe('collab');
-            expect(billing?.entitlement_state).toBe('active');
+            expect(billing?.entitlement_state).toBe('trialing');
         }
         finally {
             core.close();
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('fails registration when auto-assign signup config is stale or invalid', () => {
+    it('fails registration when the onboarding policy is stale or invalid', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
             core.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'auto_assign_default',
-                    defaultSignupPlanVersionId: 'missing-v9'
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'auto_grant_free',
+                        planVersionId: 'missing-v9'
+                    }
                 }
             });
             expect(() => core.registerPasswordUser({
@@ -176,9 +197,11 @@ describe('TaskforceCore system admin model', () => {
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
             core.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'plan_selection_required',
-                    defaultSignupPlanVersionId: null
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'require_plan_selection',
+                        planVersionId: null
+                    }
                 }
             });
             const created = core.registerPasswordUser({
@@ -186,7 +209,7 @@ describe('TaskforceCore system admin model', () => {
                 password: 'password123'
             });
             expect(created.planSelectionRequired).toBe(true);
-            expect(core.hasAccountEntitlement(created.userId)).toBe(false);
+            expect(core.hasAccountEntitlement(created.userId)).toBe(true);
             const db = core.db;
             const billing = db.prepare(`
                 SELECT entitlement_state, tier
@@ -198,7 +221,7 @@ describe('TaskforceCore system admin model', () => {
             expect(String(billing?.tier || '')).toBe('');
             expect(core.getAccountAccessStatus(created.userId)).toMatchObject({
                 gate: 'plan_selection_required',
-                hasEntitlement: false,
+                hasEntitlement: true,
                 canAccessApp: false,
                 canAccessPlans: true
             });
@@ -245,7 +268,7 @@ describe('TaskforceCore system admin model', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('assigns the explicitly selected signup plan version instead of the default signup plan', () => {
+    it('assigns the explicitly selected plan version instead of the configured onboarding plan', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
@@ -255,11 +278,14 @@ describe('TaskforceCore system admin model', () => {
                 versionNumber: 1,
                 seatLimit: 1
             });
+            insertFreePriceMapping(core, 'free-v1');
             core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'archived' });
             core.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'auto_assign_default',
-                    defaultSignupPlanVersionId: 'starter-v1'
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'auto_grant_free',
+                        planVersionId: 'starter-v1'
+                    }
                 }
             });
             const created = core.registerPasswordUser({
@@ -279,14 +305,16 @@ describe('TaskforceCore system admin model', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('treats accounts without an entitlement or pending-selection marker as plan selection required', () => {
+    it('treats accounts without an entitlement or pending-selection marker as missing entitlement', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
             core.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'plan_selection_required',
-                    defaultSignupPlanVersionId: null
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'require_plan_selection',
+                        planVersionId: null
+                    }
                 }
             });
             const now = new Date().toISOString();
@@ -296,10 +324,10 @@ describe('TaskforceCore system admin model', () => {
                 VALUES (?, ?, ?, ?, ?, ?, ?, 'user', 1, 0, ?, ?)
             `).run('user-missing-entitlement', 'default', 'broken@example.com', 'Broken', 'password', 'broken@example.com', 'hash', now, now);
             expect(core.getAccountAccessStatus('user-missing-entitlement')).toMatchObject({
-                gate: 'plan_selection_required',
+                gate: 'missing_entitlement',
                 hasEntitlement: false,
                 canAccessApp: false,
-                planSelectionRequired: true
+                planSelectionRequired: false
             });
         }
         finally {
@@ -339,13 +367,16 @@ describe('TaskforceCore system admin model', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('persists signup monetization defaults during startup for existing installs', () => {
+    it('preserves require_plan_selection onboarding policy across restart', () => {
         const projectRoot = makeProjectRoot();
         const initial = openCore(projectRoot, { seedDefaultPlans: true });
         try {
             initial.updateGlobalSettings({
-                auth: {
-                    allowSelfRegistration: true
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'require_plan_selection',
+                        planVersionId: null
+                    }
                 }
             });
         }
@@ -354,70 +385,9 @@ describe('TaskforceCore system admin model', () => {
         }
         const reopened = openCore(projectRoot, { seedDefaultPlans: false });
         try {
-            expect(reopened.getSignupMonetizationSettings()).toEqual({
-                strategy: 'auto_assign_default',
-                defaultSignupPlanVersionId: 'starter-v1'
-            });
-            expect(reopened.getGlobalSettings().auth).toMatchObject({
-                signupMonetizationStrategy: 'auto_assign_default',
-                defaultSignupPlanVersionId: 'starter-v1'
-            });
-        }
-        finally {
-            reopened.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('repairs signup monetization defaults on the same startup pass that repairs missing plan defaults', () => {
-        const projectRoot = makeProjectRoot();
-        const initial = openCore(projectRoot, { seedDefaultPlans: true });
-        try {
-            initial.updateGlobalSettings({
-                auth: {
-                    allowSelfRegistration: true
-                }
-            });
-            const db = initial.db;
-            db.prepare(`
-                UPDATE plan_versions
-                SET is_default = 0
-                WHERE tenant_id = ? AND plan_id = ?
-            `).run('default', 'starter');
-        }
-        finally {
-            initial.close();
-        }
-        const reopened = openCore(projectRoot, { seedDefaultPlans: false });
-        try {
-            expect(reopened.getSignupMonetizationSettings()).toEqual({
-                strategy: 'auto_assign_default',
-                defaultSignupPlanVersionId: 'starter-v1'
-            });
-        }
-        finally {
-            reopened.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('does not inject a default signup plan version when strategy is plan selection required', () => {
-        const projectRoot = makeProjectRoot();
-        const initial = openCore(projectRoot, { seedDefaultPlans: true });
-        try {
-            initial.updateGlobalSettings({
-                auth: {
-                    signupMonetizationStrategy: 'plan_selection_required',
-                    defaultSignupPlanVersionId: null
-                }
-            });
-        }
-        finally {
-            initial.close();
-        }
-        const reopened = openCore(projectRoot, { seedDefaultPlans: false });
-        try {
-            expect(reopened.getSignupMonetizationSettings()).toEqual({
-                strategy: 'plan_selection_required',
-                defaultSignupPlanVersionId: null
+            expect(reopened.getOnboardingPolicy()).toEqual({
+                mode: 'require_plan_selection',
+                planVersionId: null
             });
         }
         finally {
@@ -663,6 +633,126 @@ describe('TaskforceCore system admin model', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('purges a non-production test user and clears active ownership references', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot, { seedDefaultPlans: true });
+        try {
+            const admin = core.registerPasswordUser({
+                email: 'admin@example.com',
+                password: 'password123'
+            });
+            const member = core.registerPasswordUser({
+                email: 'member@example.com',
+                password: 'password123'
+            });
+            const workspaceId = member.workspaceId || 'default';
+            const db = core.db;
+            db.prepare(`
+                UPDATE workspace_memberships
+                SET role = 'member', updated_at = ?
+                WHERE tenant_id = ? AND user_id = ?
+            `).run(new Date().toISOString(), 'default', member.userId);
+            const task = core.createTask({
+                title: 'Signup test task',
+                assignee: member.userId
+            }, { workspaceId });
+            const initiative = core.createInitiative({
+                title: 'Signup initiative',
+                ownerId: member.userId
+            }, workspaceId);
+            const workstream = core.createWorkstream({
+                title: 'Signup workstream',
+                ownerId: member.userId
+            }, workspaceId);
+            const now = new Date().toISOString();
+            db.prepare(`
+                INSERT INTO ui_state (tenant_id, workspace_id, user_id, state_key, payload, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+            `).run('default', workspaceId, member.userId, 'admin.users', '{"open":true}', now);
+            db.prepare(`
+                INSERT INTO user_preferences (tenant_id, user_id, prefs_key, payload, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+            `).run('default', member.userId, 'profile', '{"theme":"light"}', now);
+            const summary = core.purgeSystemUser({
+                targetUserId: member.userId,
+                actorUserId: admin.userId,
+                emailConfirmation: 'member@example.com'
+            });
+            expect(summary).toMatchObject({
+                targetUserId: member.userId,
+                email: 'member@example.com',
+                unassignedTaskCount: 1,
+                clearedInitiativeOwnerCount: 1,
+                clearedWorkstreamOwnerCount: 1,
+                deletedUiStateCount: 1,
+                deletedUserPreferenceCount: 1,
+                deletedUserCount: 1
+            });
+            expect(db.prepare(`SELECT assignee FROM tasks WHERE id = ?`).get(task.id)).toMatchObject({
+                assignee: 'unassigned'
+            });
+            expect(db.prepare(`SELECT owner_id FROM initiatives WHERE id = ?`).get(initiative.id)).toMatchObject({
+                owner_id: null
+            });
+            expect(db.prepare(`SELECT owner_id FROM workstreams WHERE id = ?`).get(workstream.id)).toMatchObject({
+                owner_id: null
+            });
+            expect(db.prepare(`SELECT COUNT(*) AS count FROM users WHERE tenant_id = ? AND id = ?`).get('default', member.userId)).toMatchObject({
+                count: 0
+            });
+            expect(db.prepare(`SELECT COUNT(*) AS count FROM account_entitlements WHERE tenant_id = ? AND account_id = ?`).get('default', member.userId)).toMatchObject({
+                count: 0
+            });
+            expect(db.prepare(`SELECT COUNT(*) AS count FROM ui_state WHERE tenant_id = ? AND user_id = ?`).get('default', member.userId)).toMatchObject({
+                count: 0
+            });
+            expect(db.prepare(`SELECT COUNT(*) AS count FROM user_preferences WHERE tenant_id = ? AND user_id = ?`).get('default', member.userId)).toMatchObject({
+                count: 0
+            });
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('blocks purging a user with active commercial billing state', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot, { seedDefaultPlans: true });
+        try {
+            const admin = core.registerPasswordUser({
+                email: 'admin@example.com',
+                password: 'password123'
+            });
+            const member = core.registerPasswordUser({
+                email: 'member@example.com',
+                password: 'password123'
+            });
+            const db = core.db;
+            const now = new Date().toISOString();
+            db.prepare(`
+                UPDATE workspace_memberships
+                SET role = 'member', updated_at = ?
+                WHERE tenant_id = ? AND user_id = ?
+            `).run(now, 'default', member.userId);
+            db.prepare(`
+                INSERT INTO user_billing (
+                    user_id, tenant_id, stripe_customer_id, entitlement_state, tier, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT (user_id) DO UPDATE SET
+                    stripe_customer_id = excluded.stripe_customer_id,
+                    updated_at = excluded.updated_at
+            `).run(member.userId, 'default', 'cus_test_123', 'active', 'starter', now, now);
+            expect(() => core.purgeSystemUser({
+                targetUserId: member.userId,
+                actorUserId: admin.userId,
+                emailConfirmation: 'member@example.com'
+            })).toThrowError(/active commercial billing state/i);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('creates v1 automatically when a new plan is created', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot, { seedDefaultPlans: true });

package/dist/core/TaskActivityService.d.ts

@@ -1,5 +1,6 @@
 import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
-import type { Comment, TaskActivityItem, TaskActor, TaskEvent, TaskEventDetails } from './Taskforce.js';
+import type { TaskActor } from '../shared/taskActor.js';
+import type { Comment, TaskActivityItem, TaskEvent, TaskEventDetails } from './Taskforce.js';
 export interface TaskActivityServiceDeps {
     db: DatabaseAdapter;
     tenantId: string;
@@ -7,6 +8,7 @@ export interface TaskActivityServiceDeps {
     normalizeWorkspaceId: (workspaceId: string | undefined) => string;
     resolveWorkspaceActor: (workspaceId: string, actorRef: unknown) => TaskActor | null;
 }
+export declare function listWorkspaceTaskEventsService(deps: TaskActivityServiceDeps, workspaceId: string): TaskEvent[];
 export declare function replaceTaskCommentsService(deps: TaskActivityServiceDeps, taskId: string, workspaceId: string, comments: Comment[]): void;
 export declare function listTaskEventsInternalService(deps: TaskActivityServiceDeps, taskId: string, workspaceId: string): TaskEvent[];
 export declare function buildTaskActivityService(comments: Comment[], taskEvents: TaskEvent[]): TaskActivityItem[];
@@ -19,3 +21,4 @@ export declare function addTaskEventService(deps: TaskActivityServiceDeps, input
     details?: TaskEventDetails;
 }): void;
 export declare function replaceTaskEventsService(deps: TaskActivityServiceDeps, taskId: string, workspaceId: string, taskEvents: TaskEvent[]): void;
+export declare function upsertTaskEventForSyncService(deps: TaskActivityServiceDeps, event: TaskEvent): TaskEvent;

package/dist/core/TaskActivityService.js

@@ -39,6 +39,17 @@ function mapTaskEventRow(deps, row) {
         actorProfile: actor === 'system' ? null : deps.resolveWorkspaceActor(workspaceId, actor)
     };
 }
+export function listWorkspaceTaskEventsService(deps, workspaceId) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const rows = deps.db.prepare(`
+        SELECT id, task_id, workspace_id, action, actor, actor_type, details_json, created_at
+        FROM task_events
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+        ORDER BY created_at ASC, id ASC
+    `).all(deps.tenantId, normalizedWorkspaceId);
+    return rows.map((row) => mapTaskEventRow(deps, row));
+}
 export function replaceTaskCommentsService(deps, taskId, workspaceId, comments) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
     deps.db.prepare('DELETE FROM comments WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?')
@@ -128,3 +139,37 @@ export function replaceTaskEventsService(deps, taskId, workspaceId, taskEvents)
         insertTaskEvent.run(event.id, deps.tenantId, normalizedWorkspaceId, taskId, event.action, event.actor, event.actorType, JSON.stringify(normalizeTaskEventDetails(event.details)), event.createdAt);
     }
 }
+export function upsertTaskEventForSyncService(deps, event) {
+    const workspaceId = deps.normalizeWorkspaceId(event.workspaceId);
+    const normalizedEvent = {
+        id: String(event.id || '').trim(),
+        taskId: String(event.taskId || '').trim(),
+        workspaceId,
+        action: String(event.action || '').trim(),
+        actor: String(event.actor || 'system').trim() || 'system',
+        actorType: event.actorType === 'ai' || event.actorType === 'human' || event.actorType === 'system'
+            ? event.actorType
+            : 'system',
+        createdAt: String(event.createdAt || '').trim() || new Date().toISOString(),
+        details: normalizeTaskEventDetails(event.details)
+    };
+    deps.db.prepare(`
+        INSERT INTO task_events (
+            id, tenant_id, workspace_id, task_id, action, actor, actor_type, details_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT (id) DO UPDATE SET
+            workspace_id = excluded.workspace_id,
+            task_id = excluded.task_id,
+            action = excluded.action,
+            actor = excluded.actor,
+            actor_type = excluded.actor_type,
+            details_json = excluded.details_json,
+            created_at = excluded.created_at
+    `).run(normalizedEvent.id, deps.tenantId, workspaceId, normalizedEvent.taskId, normalizedEvent.action, normalizedEvent.actor, normalizedEvent.actorType, JSON.stringify(normalizedEvent.details), normalizedEvent.createdAt);
+    return {
+        ...normalizedEvent,
+        actorProfile: normalizedEvent.actor === 'system'
+            ? null
+            : deps.resolveWorkspaceActor(workspaceId, normalizedEvent.actor)
+    };
+}

package/dist/core/TaskAuditTimeline.test.js

@@ -92,7 +92,7 @@ describe('TaskforceCore task audit timeline', () => {
             cleanup();
         }
     });
-    it('suppresses task events for autosave-style updates when skipTaskEvents is true', () => {
+    it('suppresses task events when skipTaskEvents is explicitly true', () => {
         const { core, cleanup } = makeCore();
         try {
             const task = core.createTask({ title: 'Autosave task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
@@ -110,6 +110,57 @@ describe('TaskforceCore task audit timeline', () => {
             cleanup();
         }
     });
+    it('suppresses title and description autosave events while preserving the saved task content', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const task = core.createTask({ title: 'Autosave title task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            core.updateTask(task.id, {
+                title: 'Autosave title task updated',
+                description: 'Draft body'
+            }, 'workspace-a', {
+                actorRef: 'user',
+                saveSource: 'autosave'
+            });
+            const events = core.listTaskEvents(task.id, 'workspace-a');
+            const hydrated = core.getTask(task.id, 'workspace-a');
+            expect(events.map((event) => event.action)).toEqual(['task-created']);
+            expect(hydrated?.title).toBe('Autosave title task updated');
+            expect(hydrated?.description).toBe('Draft body');
+            expect(hydrated?.activity?.some((item) => item.type === 'event' && item.event.action === 'task-updated')).toBe(false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('keeps meaningful autosave updates in the activity feed while filtering noisy text changes', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const task = core.createTask({ title: 'Autosave assignee task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            core.updateTask(task.id, {
+                title: 'Autosave assignee task updated',
+                assignee: 'member-1'
+            }, 'workspace-a', {
+                actorRef: 'user',
+                saveSource: 'autosave'
+            });
+            const assignmentEvent = core.listTaskEvents(task.id, 'workspace-a').find((event) => event.action === 'task-updated' && event.details?.changes?.assignee);
+            expect(assignmentEvent).toEqual(expect.objectContaining({
+                action: 'task-updated',
+                details: {
+                    changes: {
+                        assignee: {
+                            from: 'unassigned',
+                            to: 'member-1',
+                        },
+                    },
+                },
+            }));
+            expect(assignmentEvent?.details?.changes?.title).toBeUndefined();
+        }
+        finally {
+            cleanup();
+        }
+    });
     it('captures assignment changes in the core task update event details', () => {
         const { core, cleanup } = makeCore();
         try {