@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/core/SystemAdmin.test.js

@@ -16,21 +16,34 @@ function insertFreePriceMapping(core, planVersionId) {
     `).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.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+    core.upsertPlanCatalog({ planId: 'basic', displayName: 'Basic', status: 'active' });
+    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
     core.updatePlanVersion({
-        planId: 'collab',
+        planId: 'basic',
+        versionNumber: 1,
+        seatLimit: null
+    });
+    core.updatePlanVersion({
+        planId: 'team-5',
         versionNumber: 1,
         seatLimit: 5
     });
     core.updatePlanVersionFeatures({
-        planVersionId: 'starter-v1',
+        planVersionId: 'free-v1',
+        features: [
+            { featureKey: 'workspace.switching', access: 'enabled' }
+        ]
+    });
+    core.updatePlanVersionFeatures({
+        planVersionId: 'basic-v1',
         features: [
+            { featureKey: 'context.uploads', access: 'enabled' },
             { featureKey: 'workspace.switching', access: 'enabled' }
         ]
     });
     core.updatePlanVersionFeatures({
-        planVersionId: 'collab-v1',
+        planVersionId: 'team-5-v1',
         features: [
             { featureKey: 'collaboration.invites', access: 'enabled' },
             { featureKey: 'collaboration.team_management', access: 'enabled' },
@@ -38,7 +51,7 @@ function seedPlanCatalog(core) {
             { featureKey: 'workspace.switching', access: 'enabled' }
         ]
     });
-    insertFreePriceMapping(core, 'starter-v1');
+    insertFreePriceMapping(core, 'free-v1');
 }
 function seedPlans(core) {
     seedPlanCatalog(core);
@@ -46,7 +59,7 @@ function seedPlans(core) {
         billing: {
             onboardingPolicy: {
                 mode: 'auto_grant_free',
-                planVersionId: 'starter-v1'
+                planVersionId: 'free-v1'
             }
         }
     });
@@ -78,7 +91,7 @@ describe('TaskforceCore system admin model', () => {
                 LIMIT 1
             `).get('default', created.userId);
             expect(row?.user_id).toBe(created.userId);
-            expect(row?.tier).toBe('starter');
+            expect(row?.tier).toBe('free');
             expect(row?.entitlement_state).toBe('active');
         }
         finally {
@@ -105,7 +118,7 @@ describe('TaskforceCore system admin model', () => {
                 LIMIT 1
             `).get('default', created.userId);
             expect(row?.user_id).toBe(created.userId);
-            expect(row?.tier).toBe('starter');
+            expect(row?.tier).toBe('free');
             expect(row?.entitlement_state).toBe('active');
         }
         finally {
@@ -118,14 +131,14 @@ describe('TaskforceCore system admin model', () => {
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
             core.createPlanVersion({
-                planId: 'collab',
+                planId: 'team-5',
                 versionNumber: 2,
                 isDefault: true,
                 seatLimit: 10,
                 trialDays: 14
             });
             core.updatePlanVersionFeatures({
-                planVersionId: 'collab-v2',
+                planVersionId: 'team-5-v2',
                 features: [
                     { featureKey: 'collaboration.invites', access: 'enabled' },
                     { featureKey: 'collaboration.team_management', access: 'enabled' },
@@ -134,7 +147,7 @@ describe('TaskforceCore system admin model', () => {
                 ]
             });
             core.createPlanVersion({
-                planId: 'starter',
+                planId: 'free',
                 versionNumber: 2,
                 isDefault: false,
                 seatLimit: null
@@ -143,7 +156,7 @@ describe('TaskforceCore system admin model', () => {
                 billing: {
                     onboardingPolicy: {
                         mode: 'auto_start_trial',
-                        planVersionId: 'collab-v2'
+                        planVersionId: 'team-5-v2'
                     }
                 }
             });
@@ -159,10 +172,10 @@ describe('TaskforceCore system admin model', () => {
                 WHERE tenant_id = ? AND user_id = ?
                 LIMIT 1
             `).get(core.getTenantId(), created.userId);
-            expect(entitlement.planVersionId).toBe('collab-v2');
-            expect(entitlement.planId).toBe('collab');
+            expect(entitlement.planVersionId).toBe('team-5-v2');
+            expect(entitlement.planId).toBe('team-5');
             expect(entitlement.state).toBe('trialing');
-            expect(billing?.tier).toBe('collab');
+            expect(billing?.tier).toBe('team-5');
             expect(billing?.entitlement_state).toBe('trialing');
         }
         finally {
@@ -244,7 +257,7 @@ describe('TaskforceCore system admin model', () => {
                     access = excluded.access,
                     config_json = excluded.config_json,
                     updated_at = excluded.updated_at
-            `).run('default', 'collab-v1', 'documents.workspace_access', 'enabled', '{}', now, now);
+            `).run('default', 'team-5-v1', 'documents.workspace_access', 'enabled', '{}', now, now);
         }
         finally {
             core.close();
@@ -257,9 +270,9 @@ describe('TaskforceCore system admin model', () => {
                 FROM plan_feature_matrix
                 WHERE tenant_id = ? AND plan_version_id = ? AND feature_key = ?
                 LIMIT 1
-            `).get('default', 'collab-v1', 'documents.workspace_access');
+            `).get('default', 'team-5-v1', 'documents.workspace_access');
             expect(row).toBeUndefined();
-            const snapshot = core.listPlanVersions('collab').find((version) => version.planVersionId === 'collab-v1');
+            const snapshot = core.listPlanVersions('team-5').find((version) => version.planVersionId === 'team-5-v1');
             expect(snapshot).toBeDefined();
             expect(snapshot.features['documents.workspace_access']).toBeUndefined();
         }
@@ -268,34 +281,120 @@ describe('TaskforceCore system admin model', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('assigns the explicitly selected plan version instead of the configured onboarding plan', () => {
+    it('keeps configured auto-grant onboarding plan when registration includes a selected plan version', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
-            core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
             core.updatePlanVersion({
-                planId: 'free',
+                planId: 'basic',
                 versionNumber: 1,
-                seatLimit: 1
+                seatLimit: null
             });
-            insertFreePriceMapping(core, 'free-v1');
-            core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'archived' });
             core.updateGlobalSettings({
                 billing: {
                     onboardingPolicy: {
                         mode: 'auto_grant_free',
-                        planVersionId: 'starter-v1'
+                        planVersionId: 'free-v1'
                     }
                 }
             });
             const created = core.registerPasswordUser({
                 email: 'selected-plan@example.com',
                 password: 'password123',
-                planVersionId: 'free-v1'
+                planVersionId: 'basic-v1'
+            });
+            expect(created.planSelectionRequired).toBe(false);
+            expect(core.getAccountEntitlement(created.userId)).toMatchObject({
+                planVersionId: 'free-v1',
+                planId: 'free',
+                state: 'active'
+            });
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('uses the explicitly selected plan version when onboarding requires plan selection', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot, { seedDefaultPlans: true });
+        try {
+            core.updatePlanVersion({
+                planId: 'basic',
+                versionNumber: 1,
+                seatLimit: null
+            });
+            core.updateGlobalSettings({
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'require_plan_selection',
+                        planVersionId: null
+                    }
+                }
+            });
+            const created = core.registerPasswordUser({
+                email: 'selected-plan-required@example.com',
+                password: 'password123',
+                planVersionId: 'basic-v1'
             });
             expect(created.planSelectionRequired).toBe(false);
             expect(core.getAccountEntitlement(created.userId)).toMatchObject({
+                planVersionId: 'basic-v1',
+                planId: 'basic',
+                state: 'checkout_pending'
+            });
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('auto-heals stranded legacy personal free entitlements onto the active default free version', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot, { seedDefaultPlans: true });
+        try {
+            core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+            insertFreePriceMapping(core, 'free-v1');
+            core.createPlanVersion({
+                planId: 'free',
+                versionNumber: 2,
+                isDefault: true,
+                seatLimit: 1
+            });
+            insertFreePriceMapping(core, 'free-v2');
+            core.updateGlobalSettings({
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'require_plan_selection',
+                        planVersionId: null
+                    }
+                }
+            });
+            const created = core.registerPasswordUser({
+                email: 'legacy-free@example.com',
+                password: 'password123',
+                planVersionId: 'free-v1'
+            });
+            core.updateAccountEntitlement({
+                accountId: created.userId,
                 planVersionId: 'free-v1',
+                entitlementState: 'canceled',
+                actorUserId: created.userId,
+                actorRole: 'user',
+                reason: 'legacy-free-v1-canceled'
+            });
+            expect(core.getAccountAccessStatus(created.userId)).toMatchObject({
+                gate: 'ok',
+                hasEntitlement: true,
+                canAccessApp: true,
+                entitlement: {
+                    planVersionId: 'free-v2',
+                    planId: 'free',
+                    state: 'active'
+                }
+            });
+            expect(core.getAccountEntitlement(created.userId)).toMatchObject({
+                planVersionId: 'free-v2',
                 planId: 'free',
                 state: 'active'
             });
@@ -305,6 +404,61 @@ describe('TaskforceCore system admin model', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('does not auto-heal canceled accounts already on the current default free version', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot, { seedDefaultPlans: true });
+        try {
+            core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+            insertFreePriceMapping(core, 'free-v1');
+            core.createPlanVersion({
+                planId: 'free',
+                versionNumber: 2,
+                isDefault: true,
+                seatLimit: 1
+            });
+            insertFreePriceMapping(core, 'free-v2');
+            core.updateGlobalSettings({
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'require_plan_selection',
+                        planVersionId: null
+                    }
+                }
+            });
+            const created = core.registerPasswordUser({
+                email: 'current-default-free@example.com',
+                password: 'password123',
+                planVersionId: 'free-v2'
+            });
+            core.updateAccountEntitlement({
+                accountId: created.userId,
+                planVersionId: 'free-v2',
+                entitlementState: 'canceled',
+                actorUserId: created.userId,
+                actorRole: 'user',
+                reason: 'intentional-free-v2-cancel'
+            });
+            expect(core.getAccountAccessStatus(created.userId)).toMatchObject({
+                gate: 'missing_entitlement',
+                hasEntitlement: true,
+                canAccessApp: false,
+                entitlement: {
+                    planVersionId: 'free-v2',
+                    planId: 'free',
+                    state: 'canceled'
+                }
+            });
+            expect(core.getAccountEntitlement(created.userId)).toMatchObject({
+                planVersionId: 'free-v2',
+                planId: 'free',
+                state: 'canceled'
+            });
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('treats accounts without an entitlement or pending-selection marker as missing entitlement', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot, { seedDefaultPlans: true });
@@ -344,7 +498,7 @@ describe('TaskforceCore system admin model', () => {
                 UPDATE plan_versions
                 SET is_default = 0
                 WHERE tenant_id = ? AND plan_id = ?
-            `).run('default', 'starter');
+            `).run('default', 'free');
         }
         finally {
             initial.close();
@@ -357,10 +511,10 @@ describe('TaskforceCore system admin model', () => {
                 FROM plan_versions
                 WHERE tenant_id = ? AND plan_id = ? AND plan_version_id = ?
                 LIMIT 1
-            `).get('default', 'starter', 'starter-v1');
-            expect(row?.plan_version_id).toBe('starter-v1');
+            `).get('default', 'free', 'free-v1');
+            expect(row?.plan_version_id).toBe('free-v1');
             expect(row?.is_default).toBe(1);
-            expect(reopened.getRequiredDefaultPlanVersionId('starter')).toBe('starter-v1');
+            expect(reopened.getRequiredDefaultPlanVersionId('free')).toBe('free-v1');
         }
         finally {
             reopened.close();
@@ -405,7 +559,7 @@ describe('TaskforceCore system admin model', () => {
                 UPDATE plan_versions
                 SET seat_limit = NULL, updated_at = ?
                 WHERE tenant_id = ? AND plan_version_id = ?
-            `).run(now, 'default', 'collab-v1');
+            `).run(now, 'default', 'team-5-v1');
             db.prepare(`
                 INSERT INTO plan_feature_matrix (tenant_id, plan_version_id, feature_key, access, config_json, created_at, updated_at)
                 VALUES (?, ?, 'collaboration.seat_limit', 'limited', ?, ?, ?)
@@ -413,14 +567,14 @@ describe('TaskforceCore system admin model', () => {
                     access = excluded.access,
                     config_json = excluded.config_json,
                     updated_at = excluded.updated_at
-            `).run('default', 'collab-v1', JSON.stringify({ seat_limit: 7 }), now, now);
+            `).run('default', 'team-5-v1', JSON.stringify({ seat_limit: 7 }), now, now);
         }
         finally {
             initial.close();
         }
         const reopened = openCore(projectRoot, { seedDefaultPlans: false });
         try {
-            const version = reopened.getPlanVersionFeatures('collab', 'collab-v1');
+            const version = reopened.getPlanVersionFeatures('team-5', 'team-5-v1');
             expect(version.seatLimit).toBe(7);
             expect(version.features['collaboration.seat_limit']?.config || {}).toEqual({});
         }
@@ -453,13 +607,15 @@ describe('TaskforceCore system admin model', () => {
         const reopened = openCore(projectRoot, { seedDefaultPlans: false });
         try {
             const db = reopened.db;
+            const normalizedPersonalVersionId = reopened.getDefaultPlanVersionIdByMode('personal');
+            const normalizedBillingMirror = reopened.getBillingMirrorProfileForPlanVersion(normalizedPersonalVersionId);
             const row = db.prepare(`
                 SELECT tier, entitlement_state
                 FROM user_billing
                 WHERE tenant_id = ? AND user_id = ?
                 LIMIT 1
             `).get('default', legacyUserId);
-            expect(row?.tier).toBe('starter');
+            expect(row?.tier).toBe(normalizedBillingMirror.planId);
             expect(row?.entitlement_state).toBe('active');
         }
         finally {
@@ -490,11 +646,11 @@ describe('TaskforceCore system admin model', () => {
             db.prepare(`
                 INSERT INTO plan_catalog (plan_id, tenant_id, display_name, status, created_at, updated_at)
                 VALUES (?, ?, ?, 'active', ?, ?)
-            `).run('enterprise', 'default', 'Enterprise', now, now);
+            `).run('agency', 'default', 'Agency', now, now);
             db.prepare(`
                 INSERT INTO plan_versions (plan_version_id, tenant_id, plan_id, version_number, is_default, seat_limit, metadata_json, created_at, updated_at)
                 VALUES (?, ?, ?, 1, 1, 25, '{}', ?, ?)
-            `).run('enterprise-v1', 'default', 'enterprise', now, now);
+            `).run('agency-v1', 'default', 'agency', now, now);
         }
         finally {
             initial.close();
@@ -502,8 +658,8 @@ describe('TaskforceCore system admin model', () => {
         const reopened = openCore(projectRoot, { seedDefaultPlans: false });
         try {
             const plans = reopened.listPlanCatalog();
-            expect(plans.map((plan) => plan.planId)).toEqual(['enterprise']);
-            expect(reopened.getDefaultPlanVersionIdByMode('personal')).toBe('enterprise-v1');
+            expect(plans.map((plan) => plan.planId)).toEqual(['agency']);
+            expect(reopened.getDefaultPlanVersionIdByMode('personal')).toBe('agency-v1');
         }
         finally {
             reopened.close();
@@ -613,13 +769,13 @@ describe('TaskforceCore system admin model', () => {
                 password: 'password123'
             });
             core.createPlanVersion({
-                planId: 'starter',
+                planId: 'free',
                 versionNumber: 2,
                 isDefault: true
             });
             core.updateAccountEntitlement({
                 accountId: member.userId,
-                planVersionId: 'starter-v2',
+                planVersionId: 'free-v2',
                 entitlementState: 'active',
                 actorUserId: admin.userId,
                 actorRole: 'system_admin'
@@ -741,7 +897,7 @@ describe('TaskforceCore system admin model', () => {
                 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);
+            `).run(member.userId, 'default', 'cus_test_123', 'active', 'basic', now, now);
             expect(() => core.purgeSystemUser({
                 targetUserId: member.userId,
                 actorUserId: admin.userId,
@@ -758,16 +914,16 @@ describe('TaskforceCore system admin model', () => {
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
             const plan = core.upsertPlanCatalog({
-                planId: 'enterprise',
-                displayName: 'Enterprise',
+                planId: 'agency',
+                displayName: 'Agency',
                 status: 'active'
             });
-            expect(plan.planId).toBe('enterprise');
-            const versions = core.listPlanVersions('enterprise');
+            expect(plan.planId).toBe('agency');
+            const versions = core.listPlanVersions('agency');
             expect(versions).toHaveLength(1);
             expect(versions[0]).toMatchObject({
-                planVersionId: 'enterprise-v1',
-                planId: 'enterprise',
+                planVersionId: 'agency-v1',
+                planId: 'agency',
                 versionNumber: 1,
                 isDefault: true,
                 seatLimit: null
@@ -783,24 +939,24 @@ describe('TaskforceCore system admin model', () => {
         const core = openCore(projectRoot, { seedDefaultPlans: true });
         try {
             core.upsertPlanCatalog({
-                planId: 'enterprise',
-                displayName: 'Enterprise',
+                planId: 'agency',
+                displayName: 'Agency',
                 status: 'active'
             });
             core.createPlanVersion({
-                planId: 'enterprise',
+                planId: 'agency',
                 versionNumber: 2,
                 isDefault: true,
                 seatLimit: 25
             });
             core.upsertPlanCatalog({
-                planId: 'enterprise',
-                displayName: 'Enterprise Plus',
+                planId: 'agency',
+                displayName: 'Agency Plus',
                 status: 'archived'
             });
-            const versions = core.listPlanVersions('enterprise');
-            expect(versions.map((version) => version.planVersionId)).toEqual(['enterprise-v2', 'enterprise-v1']);
-            expect(versions.find((version) => version.planVersionId === 'enterprise-v1')).toMatchObject({
+            const versions = core.listPlanVersions('agency');
+            expect(versions.map((version) => version.planVersionId)).toEqual(['agency-v2', 'agency-v1']);
+            expect(versions.find((version) => version.planVersionId === 'agency-v1')).toMatchObject({
                 isDefault: false
             });
         }

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 {