@taskforcehq/taskforce 0.3.306 → 0.3.307

package/dist/core/TaskActivityService.d.ts

@@ -1,6 +1,6 @@
 import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
 import type { TaskActor } from '../shared/taskActor.js';
-import type { Comment, TaskActivityItem, TaskEvent, TaskEventDetails } from './Taskforce.js';
+import type { ActivityEntityType, Comment, EntityActivityItem, EntityEvent, TaskActivityItem, TaskEvent, TaskEventDetails } from './Taskforce.js';
 export interface TaskActivityServiceDeps {
     db: DatabaseAdapter;
     tenantId: string;
@@ -9,9 +9,34 @@ export interface TaskActivityServiceDeps {
     resolveWorkspaceActor: (workspaceId: string, actorRef: unknown) => TaskActor | null;
 }
 export declare function listWorkspaceTaskEventsService(deps: TaskActivityServiceDeps, workspaceId: string): TaskEvent[];
+export declare function listWorkspaceEntityEventsService(deps: TaskActivityServiceDeps, workspaceId: string): EntityEvent[];
+export declare function listWorkspaceEntityEventsForSyncService(deps: TaskActivityServiceDeps, workspaceId: string): EntityEvent[];
+export declare function listWorkspaceTaskEventsForSyncService(deps: TaskActivityServiceDeps, workspaceId: string): TaskEvent[];
+export declare function getTaskEventForSyncService(deps: TaskActivityServiceDeps, input: {
+    taskId: string;
+    workspaceId: string;
+    eventId: string;
+}): TaskEvent | null;
+export declare function getEntityEventForSyncService(deps: TaskActivityServiceDeps, input: {
+    workspaceId: string;
+    eventId: string;
+}): EntityEvent | null;
 export declare function replaceTaskCommentsService(deps: TaskActivityServiceDeps, taskId: string, workspaceId: string, comments: Comment[]): void;
+export declare function listEntityEventsInternalService(deps: TaskActivityServiceDeps, entityType: ActivityEntityType, entityId: string, workspaceId: string): EntityEvent[];
 export declare function listTaskEventsInternalService(deps: TaskActivityServiceDeps, taskId: string, workspaceId: string): TaskEvent[];
+export declare function buildEntityActivityService(comments: Comment[], entityEvents: EntityEvent[], options?: {
+    hiddenActions?: string[];
+}): EntityActivityItem[];
 export declare function buildTaskActivityService(comments: Comment[], taskEvents: TaskEvent[]): TaskActivityItem[];
+export declare function addEntityEventService(deps: TaskActivityServiceDeps, input: {
+    entityType: ActivityEntityType;
+    entityId: string;
+    workspaceId: string;
+    action: string;
+    actor: unknown;
+    createdAt?: string;
+    details?: TaskEventDetails;
+}): void;
 export declare function addTaskEventService(deps: TaskActivityServiceDeps, input: {
     taskId: string;
     workspaceId: string;
@@ -20,5 +45,7 @@ export declare function addTaskEventService(deps: TaskActivityServiceDeps, input
     createdAt?: string;
     details?: TaskEventDetails;
 }): void;
+export declare function replaceEntityEventsService(deps: TaskActivityServiceDeps, entityType: ActivityEntityType, entityId: string, workspaceId: string, entityEvents: EntityEvent[]): void;
 export declare function replaceTaskEventsService(deps: TaskActivityServiceDeps, taskId: string, workspaceId: string, taskEvents: TaskEvent[]): void;
+export declare function upsertEntityEventForSyncService(deps: TaskActivityServiceDeps, event: EntityEvent): EntityEvent;
 export declare function upsertTaskEventForSyncService(deps: TaskActivityServiceDeps, event: TaskEvent): TaskEvent;

package/dist/core/TaskActivityService.js

@@ -1,4 +1,4 @@
-function normalizeTaskEventActor(deps, actorRef, workspaceId) {
+function normalizeEntityEventActor(deps, actorRef, workspaceId) {
     const actorProfile = deps.resolveWorkspaceActor(workspaceId, actorRef);
     const actor = String(actorRef || '').trim() || 'system';
     if (actor === 'system') {
@@ -10,25 +10,48 @@ function normalizeTaskEventActor(deps, actorRef, workspaceId) {
         actorProfile
     };
 }
-function normalizeTaskEventDetails(details) {
+function normalizeEntityEventDetails(details) {
     if (!details || typeof details !== 'object' || Array.isArray(details))
         return {};
     return details;
 }
-function mapTaskEventRow(deps, row) {
+function normalizeEntityType(value) {
+    return value === 'initiative' || value === 'workstream' ? value : 'task';
+}
+function mapEntityEventRow(deps, row) {
     const workspaceId = deps.normalizeWorkspaceId(typeof row.workspace_id === 'string' ? row.workspace_id : undefined);
     const actor = String(row.actor || 'system').trim() || 'system';
+    const entityType = normalizeEntityType(row.entity_type);
+    const entityId = String(row.entity_id || row.task_id || '').trim();
     let details = {};
     try {
-        details = normalizeTaskEventDetails(row.details_json ? JSON.parse(String(row.details_json)) : {});
+        details = normalizeEntityEventDetails(row.details_json ? JSON.parse(String(row.details_json)) : {});
     }
     catch {
         details = {};
     }
+    if (entityType === 'task') {
+        return {
+            id: String(row.id || '').trim(),
+            taskId: entityId,
+            workspaceId,
+            entityType,
+            entityId,
+            action: String(row.action || '').trim(),
+            actor,
+            actorType: row.actor_type === 'ai' || row.actor_type === 'human' || row.actor_type === 'system'
+                ? row.actor_type
+                : 'system',
+            createdAt: String(row.created_at || ''),
+            details,
+            actorProfile: actor === 'system' ? null : deps.resolveWorkspaceActor(workspaceId, actor)
+        };
+    }
     return {
         id: String(row.id || '').trim(),
-        taskId: String(row.task_id || '').trim(),
         workspaceId,
+        entityType,
+        entityId,
         action: String(row.action || '').trim(),
         actor,
         actorType: row.actor_type === 'ai' || row.actor_type === 'human' || row.actor_type === 'system'
@@ -39,16 +62,124 @@ function mapTaskEventRow(deps, row) {
         actorProfile: actor === 'system' ? null : deps.resolveWorkspaceActor(workspaceId, actor)
     };
 }
+function mapEntityEventSyncRow(deps, row) {
+    const workspaceId = deps.normalizeWorkspaceId(typeof row.workspace_id === 'string' ? row.workspace_id : undefined);
+    const entityType = normalizeEntityType(row.entity_type);
+    const entityId = String(row.entity_id || row.task_id || '').trim();
+    let details = {};
+    try {
+        details = normalizeEntityEventDetails(row.details_json ? JSON.parse(String(row.details_json)) : {});
+    }
+    catch {
+        details = {};
+    }
+    if (entityType === 'task') {
+        return {
+            id: String(row.id || '').trim(),
+            taskId: entityId,
+            workspaceId,
+            entityType: 'task',
+            entityId,
+            action: String(row.action || '').trim(),
+            actor: String(row.actor || 'system').trim() || 'system',
+            actorType: row.actor_type === 'ai' || row.actor_type === 'human' || row.actor_type === 'system'
+                ? row.actor_type
+                : 'system',
+            createdAt: String(row.created_at || ''),
+            details,
+            // Sync only needs the stable event payload. Avoid actor hydration so
+            // large workspace snapshots don't blow up the Postgres worker buffer.
+            actorProfile: null
+        };
+    }
+    return {
+        id: String(row.id || '').trim(),
+        workspaceId,
+        entityType,
+        entityId,
+        action: String(row.action || '').trim(),
+        actor: String(row.actor || 'system').trim() || 'system',
+        actorType: row.actor_type === 'ai' || row.actor_type === 'human' || row.actor_type === 'system'
+            ? row.actor_type
+            : 'system',
+        createdAt: String(row.created_at || ''),
+        details,
+        // Sync only needs the stable event payload. Avoid actor hydration so
+        // large workspace snapshots don't blow up the Postgres worker buffer.
+        actorProfile: null
+    };
+}
 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
+        SELECT id, workspace_id, entity_type, entity_id, action, actor, actor_type, details_json, created_at
+        FROM entity_events
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+          AND entity_type = 'task'
+        ORDER BY created_at ASC, id ASC
+    `).all(deps.tenantId, normalizedWorkspaceId);
+    return rows.map((row) => mapEntityEventRow(deps, row));
+}
+export function listWorkspaceEntityEventsService(deps, workspaceId) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const rows = deps.db.prepare(`
+        SELECT id, workspace_id, entity_type, entity_id, action, actor, actor_type, details_json, created_at
+        FROM entity_events
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+        ORDER BY created_at ASC, id ASC
+    `).all(deps.tenantId, normalizedWorkspaceId);
+    return rows.map((row) => mapEntityEventRow(deps, row));
+}
+export function listWorkspaceEntityEventsForSyncService(deps, workspaceId) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const rows = deps.db.prepare(`
+        SELECT id, workspace_id, entity_type, entity_id, action, actor, actor_type, details_json, created_at
+        FROM entity_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));
+    return rows.map((row) => mapEntityEventSyncRow(deps, row));
+}
+export function listWorkspaceTaskEventsForSyncService(deps, workspaceId) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const rows = deps.db.prepare(`
+        SELECT id, entity_id AS task_id, workspace_id, action, actor, actor_type, details_json, created_at
+        FROM entity_events
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+          AND entity_type = 'task'
+        ORDER BY created_at ASC, id ASC
+    `).all(deps.tenantId, normalizedWorkspaceId);
+    return rows.map((row) => mapEntityEventSyncRow(deps, { ...row, entity_type: 'task', entity_id: row.task_id }));
+}
+export function getTaskEventForSyncService(deps, input) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const row = deps.db.prepare(`
+        SELECT id, entity_id AS task_id, workspace_id, action, actor, actor_type, details_json, created_at
+        FROM entity_events
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+          AND entity_type = 'task'
+          AND entity_id = ?
+          AND id = ?
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, String(input.taskId || '').trim(), String(input.eventId || '').trim());
+    return row ? mapEntityEventSyncRow(deps, { ...row, entity_type: 'task', entity_id: row.task_id }) : null;
+}
+export function getEntityEventForSyncService(deps, input) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const row = deps.db.prepare(`
+        SELECT id, workspace_id, entity_type, entity_id, action, actor, actor_type, details_json, created_at
+        FROM entity_events
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+          AND id = ?
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, String(input.eventId || '').trim());
+    return row ? mapEntityEventSyncRow(deps, row) : null;
 }
 export function replaceTaskCommentsService(deps, taskId, workspaceId, comments) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
@@ -73,19 +204,24 @@ export function replaceTaskCommentsService(deps, taskId, workspaceId, comments)
         });
     }
 }
-export function listTaskEventsInternalService(deps, taskId, workspaceId) {
+export function listEntityEventsInternalService(deps, entityType, entityId, workspaceId) {
     const rows = deps.db.prepare(`
-        SELECT id, task_id, workspace_id, action, actor, actor_type, details_json, created_at
-        FROM task_events
+        SELECT id, workspace_id, entity_type, entity_id, action, actor, actor_type, details_json, created_at
+        FROM entity_events
         WHERE tenant_id = ?
           AND workspace_id = ?
-          AND task_id = ?
+          AND entity_type = ?
+          AND entity_id = ?
         ORDER BY created_at ASC, id ASC
-    `).all(deps.tenantId, workspaceId, taskId);
-    return rows.map((row) => mapTaskEventRow(deps, row));
+    `).all(deps.tenantId, workspaceId, entityType, entityId);
+    return rows.map((row) => mapEntityEventRow(deps, row));
 }
-export function buildTaskActivityService(comments, taskEvents) {
-    const visibleTaskEvents = taskEvents.filter((event) => event.action !== 'task-comment-added');
+export function listTaskEventsInternalService(deps, taskId, workspaceId) {
+    return listEntityEventsInternalService(deps, 'task', taskId, workspaceId);
+}
+export function buildEntityActivityService(comments, entityEvents, options) {
+    const hiddenActions = new Set(options?.hiddenActions || []);
+    const visibleEvents = entityEvents.filter((event) => !hiddenActions.has(event.action));
     return [
         ...comments.map((comment) => ({
             id: `comment:${comment.id}`,
@@ -93,7 +229,7 @@ export function buildTaskActivityService(comments, taskEvents) {
             timestamp: comment.timestamp,
             comment
         })),
-        ...visibleTaskEvents.map((event) => ({
+        ...visibleEvents.map((event) => ({
             id: `event:${event.id}`,
             type: 'event',
             timestamp: event.createdAt,
@@ -108,68 +244,113 @@ export function buildTaskActivityService(comments, taskEvents) {
         return String(left.id || '').localeCompare(String(right.id || ''));
     });
 }
-export function addTaskEventService(deps, input) {
+export function buildTaskActivityService(comments, taskEvents) {
+    return buildEntityActivityService(comments, taskEvents, {
+        hiddenActions: ['task-comment-added']
+    });
+}
+export function addEntityEventService(deps, input) {
     const action = String(input.action || '').trim();
     if (!action)
         return;
-    const taskId = String(input.taskId || '').trim();
-    if (!taskId)
+    const entityId = String(input.entityId || '').trim();
+    if (!entityId)
         return;
+    const entityType = normalizeEntityType(input.entityType);
     const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
     const createdAt = String(input.createdAt || '').trim() || new Date().toISOString();
-    const { actor, actorType } = normalizeTaskEventActor(deps, input.actor, workspaceId);
+    const { actor, actorType } = normalizeEntityEventActor(deps, input.actor, workspaceId);
     deps.db.prepare(`
-        INSERT INTO task_events (
-            id, tenant_id, workspace_id, task_id, action, actor, actor_type, details_json, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(deps.generateEntityId('task-event'), deps.tenantId, workspaceId, taskId, action, actor, actorType, JSON.stringify(normalizeTaskEventDetails(input.details)), createdAt);
+        INSERT INTO entity_events (
+            id, tenant_id, workspace_id, entity_type, entity_id, action, actor, actor_type, details_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(deps.generateEntityId('entity-event'), deps.tenantId, workspaceId, entityType, entityId, action, actor, actorType, JSON.stringify(normalizeEntityEventDetails(input.details)), createdAt);
 }
-export function replaceTaskEventsService(deps, taskId, workspaceId, taskEvents) {
+export function addTaskEventService(deps, input) {
+    addEntityEventService(deps, {
+        entityType: 'task',
+        entityId: input.taskId,
+        workspaceId: input.workspaceId,
+        action: input.action,
+        actor: input.actor,
+        createdAt: input.createdAt,
+        details: input.details,
+    });
+}
+export function replaceEntityEventsService(deps, entityType, entityId, workspaceId, entityEvents) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
-    deps.db.prepare('DELETE FROM task_events WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?')
-        .run(deps.tenantId, normalizedWorkspaceId, taskId);
-    if (taskEvents.length === 0)
+    deps.db.prepare('DELETE FROM entity_events WHERE tenant_id = ? AND workspace_id = ? AND entity_type = ? AND entity_id = ?')
+        .run(deps.tenantId, normalizedWorkspaceId, entityType, entityId);
+    if (entityEvents.length === 0)
         return;
-    const insertTaskEvent = deps.db.prepare(`
-        INSERT INTO task_events (
-            id, tenant_id, workspace_id, task_id, action, actor, actor_type, details_json, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    const insertEntityEvent = deps.db.prepare(`
+        INSERT INTO entity_events (
+            id, tenant_id, workspace_id, entity_type, entity_id, action, actor, actor_type, details_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-    for (const event of taskEvents) {
-        insertTaskEvent.run(event.id, deps.tenantId, normalizedWorkspaceId, taskId, event.action, event.actor, event.actorType, JSON.stringify(normalizeTaskEventDetails(event.details)), event.createdAt);
+    for (const event of entityEvents) {
+        insertEntityEvent.run(event.id, deps.tenantId, normalizedWorkspaceId, event.entityType, event.entityId, event.action, event.actor, event.actorType, JSON.stringify(normalizeEntityEventDetails(event.details)), event.createdAt);
     }
 }
-export function upsertTaskEventForSyncService(deps, event) {
+export function replaceTaskEventsService(deps, taskId, workspaceId, taskEvents) {
+    replaceEntityEventsService(deps, 'task', taskId, workspaceId, taskEvents.map((event) => ({
+        ...event,
+        entityType: 'task',
+        entityId: String(event.entityId || event.taskId || taskId).trim(),
+        taskId: String(event.taskId || taskId).trim(),
+    })));
+}
+export function upsertEntityEventForSyncService(deps, event) {
     const workspaceId = deps.normalizeWorkspaceId(event.workspaceId);
+    const entityType = normalizeEntityType(event.entityType);
     const normalizedEvent = {
         id: String(event.id || '').trim(),
-        taskId: String(event.taskId || '').trim(),
         workspaceId,
+        entityType,
+        entityId: String(event.entityId || (entityType === 'task' ? event.taskId : '') || '').trim(),
         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)
+        details: normalizeEntityEventDetails(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 (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO entity_events (
+            id, tenant_id, workspace_id, entity_type, entity_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,
+            entity_type = excluded.entity_type,
+            entity_id = excluded.entity_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);
+    `).run(normalizedEvent.id, deps.tenantId, workspaceId, normalizedEvent.entityType, normalizedEvent.entityId, normalizedEvent.action, normalizedEvent.actor, normalizedEvent.actorType, JSON.stringify(normalizedEvent.details), normalizedEvent.createdAt);
+    const actorProfile = normalizedEvent.actor === 'system'
+        ? null
+        : deps.resolveWorkspaceActor(workspaceId, normalizedEvent.actor);
+    if (normalizedEvent.entityType === 'task') {
+        return {
+            ...normalizedEvent,
+            entityType: 'task',
+            taskId: normalizedEvent.entityId,
+            actorProfile,
+        };
+    }
     return {
         ...normalizedEvent,
-        actorProfile: normalizedEvent.actor === 'system'
-            ? null
-            : deps.resolveWorkspaceActor(workspaceId, normalizedEvent.actor)
+        entityType: normalizedEvent.entityType,
+        actorProfile,
     };
 }
+export function upsertTaskEventForSyncService(deps, event) {
+    return upsertEntityEventForSyncService(deps, {
+        ...event,
+        entityType: 'task',
+        entityId: event.taskId,
+    });
+}

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

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

package/dist/core/TaskActivitySync.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { TaskforceCore } from './Taskforce';
+function makeCore() {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-activity-sync-'));
+    const core = new TaskforceCore({
+        projectRoot,
+        storagePath: path.join(projectRoot, '.taskforce')
+    });
+    return {
+        core,
+        cleanup: () => {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    };
+}
+describe('TaskforceCore sync activity reads', () => {
+    it('lists workspace entity events for sync without hydrating actor profiles', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const task = core.createTask({ title: 'Sync task event seed', createdBy: 'user-1' }, {
+                workspaceId: 'workspace-a',
+                actorRef: 'user-1'
+            });
+            const initiative = core.createInitiative({ title: 'Initiative seed' }, 'workspace-a', {
+                actorRef: 'user-1'
+            });
+            core.recordTaskEvent({
+                taskId: task.id,
+                workspaceId: 'workspace-a',
+                action: 'task-updated',
+                actor: 'user-1',
+                createdAt: '2026-04-28T10:00:00.000Z',
+                details: { changes: { assignee: { from: 'user-1', to: 'ai-1' } } }
+            });
+            core.updateInitiative(initiative.id, { description: 'Updated initiative body' }, 'workspace-a', {
+                actorRef: 'user-1'
+            });
+            vi.spyOn(core, 'resolveWorkspaceActor').mockImplementation(() => {
+                throw new Error('sync snapshot should not hydrate actor profiles');
+            });
+            const events = core.listEntityEventsForSync({ workspaceId: 'workspace-a' });
+            expect(events.map((event) => event.action)).toEqual(expect.arrayContaining([
+                'task-created',
+                'task-updated',
+                'initiative-created',
+                'initiative-updated',
+            ]));
+            expect(events.every((event) => event.actorProfile === null)).toBe(true);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('looks up one entity event for sync without hydrating actor profiles', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const workstream = core.createWorkstream({ title: 'Single sync event seed' }, 'workspace-a', {
+                actorRef: 'user-1'
+            });
+            core.updateWorkstream(workstream.id, {
+                description: 'Workstream moved forward'
+            }, 'workspace-a', {
+                actorRef: 'user-1'
+            });
+            const target = core.getWorkstream(workstream.id, 'workspace-a')?.entityEvents?.find((event) => event.action === 'workstream-updated');
+            expect(target).toBeTruthy();
+            vi.spyOn(core, 'resolveWorkspaceActor').mockImplementation(() => {
+                throw new Error('single sync lookup should not hydrate actor profiles');
+            });
+            const syncEvent = core.getEntityEventForSync({
+                workspaceId: 'workspace-a',
+                eventId: target.id,
+            });
+            expect(syncEvent).toEqual(expect.objectContaining({
+                id: target.id,
+                entityType: 'workstream',
+                entityId: workstream.id,
+                action: 'workstream-updated',
+                actorProfile: null,
+            }));
+        }
+        finally {
+            cleanup();
+        }
+    });
+});

package/dist/core/TaskAuditTimeline.test.js

@@ -183,6 +183,102 @@ describe('TaskforceCore task audit timeline', () => {
             cleanup();
         }
     });
+    it('records initiative and workstream activity events and exposes them on hydrated planning entities', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-a', name: 'Workspace A' });
+            const initiative = core.createInitiative({ title: 'Planning initiative' }, 'workspace-a', { actorRef: 'user' });
+            const nestedInitiative = core.createInitiative({ title: 'Nested initiative' }, 'workspace-a', { actorRef: 'user' });
+            const workstream = core.createWorkstream({
+                title: 'Planning workstream',
+                initiativeId: initiative.id,
+            }, 'workspace-a', { actorRef: 'user' });
+            const siblingWorkstream = core.createWorkstream({
+                title: 'Sibling workstream',
+                initiativeId: initiative.id,
+            }, 'workspace-a', { actorRef: 'user' });
+            core.updateInitiative(initiative.id, {
+                description: 'Refined initiative description',
+                attachments: [{ path: 'https://example.com/initiative-spec.md', caption: 'initiative spec' }],
+            }, 'workspace-a', { actorRef: 'user' });
+            core.archiveInitiative(initiative.id, 'workspace-a', { actorRef: 'user' });
+            core.unarchiveInitiative(initiative.id, 'workspace-a', { actorRef: 'user' });
+            core.updateWorkstream(workstream.id, {
+                initiativeId: nestedInitiative.id,
+            }, 'workspace-a', { actorRef: 'user' });
+            core.archiveWorkstream(workstream.id, 'workspace-a', { actorRef: 'user' });
+            core.unarchiveWorkstream(workstream.id, 'workspace-a', { actorRef: 'user' });
+            const linkedTask = core.createTask({
+                title: 'Linked task',
+                createdBy: 'user',
+                workstreamId: workstream.id,
+            }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            core.updateTask(linkedTask.id, { workstreamId: siblingWorkstream.id }, 'workspace-a', { actorRef: 'user' });
+            core.updateTask(linkedTask.id, { workstreamId: null }, 'workspace-a', { actorRef: 'user' });
+            const hydratedInitiative = core.getInitiative(initiative.id, 'workspace-a');
+            const hydratedWorkstream = core.getWorkstream(workstream.id, 'workspace-a');
+            const hydratedSiblingWorkstream = core.getWorkstream(siblingWorkstream.id, 'workspace-a');
+            const initiativeActions = (hydratedInitiative?.activity || [])
+                .filter((item) => item.type === 'event')
+                .map((item) => item.event.action);
+            const workstreamRelationshipEvent = (hydratedWorkstream?.activity || [])
+                .filter((item) => item.type === 'event')
+                .map((item) => item.event)
+                .find((event) => event.action === 'workstream-relationship-changed');
+            const workstreamActions = (hydratedWorkstream?.activity || [])
+                .filter((item) => item.type === 'event')
+                .map((item) => item.event.action);
+            const siblingWorkstreamActions = (hydratedSiblingWorkstream?.activity || [])
+                .filter((item) => item.type === 'event')
+                .map((item) => item.event.action);
+            const workstreamTaskAddedEvent = (hydratedWorkstream?.activity || [])
+                .filter((item) => item.type === 'event')
+                .map((item) => item.event)
+                .find((event) => event.action === 'workstream-task-added');
+            const workstreamTaskRemovedEvent = (hydratedWorkstream?.activity || [])
+                .filter((item) => item.type === 'event')
+                .map((item) => item.event)
+                .find((event) => event.action === 'workstream-task-removed');
+            expect(initiativeActions).toEqual(expect.arrayContaining([
+                'initiative-created',
+                'initiative-updated',
+                'initiative-archived',
+                'initiative-unarchived',
+            ]));
+            expect(workstreamActions).toEqual(expect.arrayContaining([
+                'workstream-created',
+                'workstream-relationship-changed',
+                'workstream-task-added',
+                'workstream-task-removed',
+                'workstream-archived',
+                'workstream-unarchived',
+            ]));
+            expect(siblingWorkstreamActions).toEqual(expect.arrayContaining([
+                'workstream-created',
+                'workstream-task-added',
+                'workstream-task-removed',
+            ]));
+            expect(workstreamRelationshipEvent?.details?.changes?.initiativeId).toEqual({
+                from: initiative.id,
+                to: nestedInitiative.id,
+            });
+            expect(workstreamTaskAddedEvent?.details?.taskId).toBe(linkedTask.id);
+            expect(workstreamTaskAddedEvent?.details?.taskTitle).toBe('Linked task');
+            expect(workstreamTaskAddedEvent?.details?.changes?.workstreamId).toEqual({
+                from: null,
+                to: workstream.id,
+            });
+            expect(workstreamTaskRemovedEvent?.details?.changes?.workstreamId).toEqual({
+                from: workstream.id,
+                to: siblingWorkstream.id,
+            });
+            expect(hydratedInitiative?.entityEvents?.every((event) => event.entityType === 'initiative')).toBe(true);
+            expect(hydratedWorkstream?.entityEvents?.every((event) => event.entityType === 'workstream')).toBe(true);
+        }
+        finally {
+            cleanup();
+        }
+    });
     it('repairs legacy comments tables so raw submitted authors can be stored', () => {
         const { core, cleanup } = makeCore();
         try {