@taskforcehq/taskforce 0.3.306 → 0.3.308

package/dist/core/PlanningEntities.test.js

@@ -22,13 +22,33 @@ describe('TaskforceCore planning entity persistence', () => {
         const initiative = core.createInitiative({
             title: 'Launch initiative',
             comments: [{ id: 'comment-1', author: 'user', text: 'Kickoff note', timestamp: '2026-01-01T00:00:00.000Z' }],
-            attachments: [{ path: '/tmp/launch-brief.md', caption: 'Launch brief', timestamp: '2026-01-01T00:00:00.000Z' }],
+            attachments: [{
+                    path: '/tmp/launch-brief.md',
+                    fsPath: 'workspaces/workspace-1/assets/documents/asset-launch-brief.md',
+                    caption: 'Launch brief',
+                    displayName: 'Launch Brief',
+                    originalFilename: 'launch-brief.md',
+                    assetId: 'asset-launch-brief',
+                    referenceNumber: 12,
+                    referenceLabel: 'D-12',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
         });
         const workstream = core.createWorkstream({
             title: 'Billing workstream',
             initiativeId: initiative.id,
             comments: [{ id: 'comment-2', author: 'user', text: 'Billing note', timestamp: '2026-01-01T00:00:00.000Z' }],
-            attachments: [{ path: '/tmp/billing-brief.md', caption: 'Billing brief', timestamp: '2026-01-01T00:00:00.000Z' }],
+            attachments: [{
+                    path: '/tmp/billing-brief.md',
+                    fsPath: 'workspaces/workspace-1/assets/documents/asset-billing-brief.md',
+                    caption: 'Billing brief',
+                    displayName: 'Billing Brief',
+                    originalFilename: 'billing-brief.md',
+                    assetId: 'asset-billing-brief',
+                    referenceNumber: 13,
+                    referenceLabel: 'D-13',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
         });
         const task = core.createTask({
             title: 'Adjust billing copy',
@@ -43,11 +63,29 @@ describe('TaskforceCore planning entity persistence', () => {
         const persistedTask = core.getTask(task.id);
         expect(persistedInitiative?.referenceLabel).toBe('IN-1');
         expect(persistedInitiative?.comments?.[0]?.text).toBe('Kickoff note');
-        expect(persistedInitiative?.attachments?.[0]).toMatchObject({ path: '/tmp/launch-brief.md' });
+        expect(persistedInitiative?.attachments?.[0]).toMatchObject({
+            path: '/tmp/launch-brief.md',
+            fsPath: 'workspaces/workspace-1/assets/documents/asset-launch-brief.md',
+            caption: 'Launch brief',
+            displayName: 'Launch Brief',
+            originalFilename: 'launch-brief.md',
+            assetId: 'asset-launch-brief',
+            referenceNumber: 12,
+            referenceLabel: 'D-12',
+        });
         expect(persistedWorkstream?.referenceLabel).toBe('WS-1');
         expect(persistedWorkstream?.initiativeId).toBe(initiative.id);
         expect(persistedWorkstream?.comments?.[0]?.text).toBe('Billing note');
-        expect(persistedWorkstream?.attachments?.[0]).toMatchObject({ path: '/tmp/billing-brief.md' });
+        expect(persistedWorkstream?.attachments?.[0]).toMatchObject({
+            path: '/tmp/billing-brief.md',
+            fsPath: 'workspaces/workspace-1/assets/documents/asset-billing-brief.md',
+            caption: 'Billing brief',
+            displayName: 'Billing Brief',
+            originalFilename: 'billing-brief.md',
+            assetId: 'asset-billing-brief',
+            referenceNumber: 13,
+            referenceLabel: 'D-13',
+        });
         expect(persistedTask?.workstreamId).toBe(workstream.id);
         expect(persistedTask?.checklistItems?.map((item) => item.title)).toEqual([
             'Update docs',
@@ -92,6 +130,328 @@ describe('TaskforceCore planning entity persistence', () => {
         expect(clearedTask?.workstreamId).toBeNull();
         core.close();
     });
+    it('syncs canonical attachment links for initiatives and workstreams like task attachments do', () => {
+        const core = createCore();
+        const workspaceId = 'default';
+        const assetStore = core.getWorkspaceAssetStore();
+        assetStore.upsertAsset({
+            assetId: 'asset-initiative-doc',
+            workspaceId,
+            kind: 'document',
+            logicalName: 'Initiative context',
+            originalFilename: 'initiative-context.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/default/assets/documents/initiative-context.md',
+            contentSha256: 'sha-init',
+            sizeBytes: 120,
+            documentId: 'doc-initiative-context',
+            version: 1,
+            isLatest: 1,
+        });
+        assetStore.upsertAsset({
+            assetId: 'asset-workstream-doc',
+            workspaceId,
+            kind: 'document',
+            logicalName: 'Workstream context',
+            originalFilename: 'workstream-context.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/default/assets/documents/workstream-context.md',
+            contentSha256: 'sha-workstream',
+            sizeBytes: 140,
+            documentId: 'doc-workstream-context',
+            version: 1,
+            isLatest: 1,
+        });
+        const initiative = core.createInitiative({
+            title: 'Platform',
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-initiative-doc/content',
+                    fsPath: 'workspaces/default/assets/documents/initiative-context.md',
+                    caption: 'Initiative context',
+                    assetId: 'asset-initiative-doc',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
+        }, workspaceId);
+        const workstream = core.createWorkstream({
+            title: 'Sync',
+            initiativeId: initiative.id,
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-workstream-doc/content',
+                    fsPath: 'workspaces/default/assets/documents/workstream-context.md',
+                    caption: 'Workstream context',
+                    assetId: 'asset-workstream-doc',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
+        }, workspaceId);
+        expect(assetStore.listLinksForTarget('initiative', initiative.id, workspaceId)).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-initiative-doc',
+                targetType: 'initiative',
+                targetId: initiative.id,
+                role: 'attachment',
+            })
+        ]);
+        expect(assetStore.listLinksForTarget('workstream', workstream.id, workspaceId)).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-workstream-doc',
+                targetType: 'workstream',
+                targetId: workstream.id,
+                role: 'attachment',
+            })
+        ]);
+        core.updateInitiative(initiative.id, { attachments: [] }, workspaceId);
+        core.updateWorkstream(workstream.id, { attachments: [] }, workspaceId);
+        expect(assetStore.listLinksForTarget('initiative', initiative.id, workspaceId)).toEqual([]);
+        expect(assetStore.listLinksForTarget('initiative', initiative.id, workspaceId, { includeDeleted: true })).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-initiative-doc',
+                deletedAt: expect.any(String),
+            })
+        ]);
+        expect(assetStore.listLinksForTarget('workstream', workstream.id, workspaceId)).toEqual([]);
+        expect(assetStore.listLinksForTarget('workstream', workstream.id, workspaceId, { includeDeleted: true })).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-workstream-doc',
+                deletedAt: expect.any(String),
+            })
+        ]);
+        core.close();
+    });
+    it('syncs sparse canonical document attachment links by asset id for planning entities', () => {
+        const core = createCore();
+        const workspaceId = 'default';
+        const assetStore = core.getWorkspaceAssetStore();
+        assetStore.upsertAsset({
+            assetId: 'asset-sparse-initiative-doc',
+            workspaceId,
+            kind: 'document',
+            logicalName: 'Sparse initiative context',
+            originalFilename: 'sparse-initiative.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/default/assets/documents/sparse-initiative.md',
+            contentSha256: 'sha-sparse-initiative',
+            sizeBytes: 120,
+            documentId: 'doc-sparse-initiative',
+            version: 1,
+            isLatest: 1,
+        });
+        assetStore.upsertAsset({
+            assetId: 'asset-sparse-workstream-doc',
+            workspaceId,
+            kind: 'document',
+            logicalName: 'Sparse workstream context',
+            originalFilename: 'sparse-workstream.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/default/assets/documents/sparse-workstream.md',
+            contentSha256: 'sha-sparse-workstream',
+            sizeBytes: 140,
+            documentId: 'doc-sparse-workstream',
+            version: 1,
+            isLatest: 1,
+        });
+        const initiative = core.createInitiative({
+            title: 'Platform',
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-sparse-initiative-doc/content',
+                    assetId: 'asset-sparse-initiative-doc',
+                    caption: 'Sparse initiative context',
+                    referenceLabel: 'D-101',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
+        }, workspaceId);
+        const workstream = core.createWorkstream({
+            title: 'Sync',
+            initiativeId: initiative.id,
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-sparse-workstream-doc/content',
+                    assetId: 'asset-sparse-workstream-doc',
+                    caption: 'Sparse workstream context',
+                    referenceLabel: 'D-102',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
+        }, workspaceId);
+        expect(assetStore.listLinksForTarget('initiative', initiative.id, workspaceId)).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-sparse-initiative-doc',
+                targetType: 'initiative',
+                targetId: initiative.id,
+                role: 'attachment',
+            })
+        ]);
+        expect(assetStore.listLinksForTarget('workstream', workstream.id, workspaceId)).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-sparse-workstream-doc',
+                targetType: 'workstream',
+                targetId: workstream.id,
+                role: 'attachment',
+            })
+        ]);
+        core.close();
+    });
+    it('preserves planning attachments when sync upserts omit attachment fields', () => {
+        const core = createCore();
+        const workspaceId = 'default';
+        const assetStore = core.getWorkspaceAssetStore();
+        assetStore.upsertAsset({
+            assetId: 'asset-preserved-initiative-doc',
+            workspaceId,
+            kind: 'document',
+            logicalName: 'Preserved initiative context',
+            originalFilename: 'preserved-initiative.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/default/assets/documents/preserved-initiative.md',
+            contentSha256: 'sha-preserved-initiative',
+            sizeBytes: 120,
+            documentId: 'doc-preserved-initiative',
+            version: 1,
+            isLatest: 1,
+        });
+        assetStore.upsertAsset({
+            assetId: 'asset-preserved-workstream-doc',
+            workspaceId,
+            kind: 'document',
+            logicalName: 'Preserved workstream context',
+            originalFilename: 'preserved-workstream.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/default/assets/documents/preserved-workstream.md',
+            contentSha256: 'sha-preserved-workstream',
+            sizeBytes: 140,
+            documentId: 'doc-preserved-workstream',
+            version: 1,
+            isLatest: 1,
+        });
+        const initiative = core.createInitiative({
+            title: 'Platform',
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-preserved-initiative-doc/content',
+                    assetId: 'asset-preserved-initiative-doc',
+                    caption: 'Preserved initiative context',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
+        }, workspaceId);
+        const workstream = core.createWorkstream({
+            title: 'Sync',
+            initiativeId: initiative.id,
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-preserved-workstream-doc/content',
+                    assetId: 'asset-preserved-workstream-doc',
+                    caption: 'Preserved workstream context',
+                    timestamp: '2026-01-01T00:00:00.000Z',
+                }],
+        }, workspaceId);
+        core.upsertInitiativeForSync({
+            id: initiative.id,
+            referenceNumber: initiative.referenceNumber,
+            title: 'Platform updated elsewhere',
+            description: initiative.description,
+            ownerId: initiative.ownerId,
+            createdAt: initiative.createdAt,
+            updatedAt: '2026-01-01T00:05:00.000Z',
+            order: initiative.order,
+            isArchived: false,
+        }, workspaceId);
+        core.upsertWorkstreamForSync({
+            id: workstream.id,
+            referenceNumber: workstream.referenceNumber,
+            initiativeId: initiative.id,
+            title: 'Sync updated elsewhere',
+            description: workstream.description,
+            ownerId: workstream.ownerId,
+            createdAt: workstream.createdAt,
+            updatedAt: '2026-01-01T00:05:00.000Z',
+            order: workstream.order,
+            isArchived: false,
+        }, workspaceId);
+        expect(core.getInitiative(initiative.id, workspaceId)?.attachments).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-preserved-initiative-doc',
+                caption: 'Preserved initiative context',
+            })
+        ]);
+        expect(core.getWorkstream(workstream.id, workspaceId)?.attachments).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-preserved-workstream-doc',
+                caption: 'Preserved workstream context',
+            })
+        ]);
+        expect(assetStore.listLinksForTarget('initiative', initiative.id, workspaceId)).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-preserved-initiative-doc',
+                deletedAt: null,
+            })
+        ]);
+        expect(assetStore.listLinksForTarget('workstream', workstream.id, workspaceId)).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-preserved-workstream-doc',
+                deletedAt: null,
+            })
+        ]);
+        core.close();
+    });
+    it('rejects stale planning sync upserts so older empty snapshots cannot clear newer attachments', () => {
+        const core = createCore();
+        const workspaceId = 'default';
+        const initiative = core.createInitiative({
+            title: 'Cloud initiative',
+            updatedAt: '2026-01-01T00:10:00.000Z',
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-newer-initiative-doc/content',
+                    assetId: 'asset-newer-initiative-doc',
+                    caption: 'Newer initiative doc',
+                    timestamp: '2026-01-01T00:10:00.000Z',
+                }],
+        }, workspaceId);
+        const workstream = core.createWorkstream({
+            title: 'Cloud workstream',
+            initiativeId: initiative.id,
+            updatedAt: '2026-01-01T00:10:00.000Z',
+            attachments: [{
+                    path: '/api/taskforce/documents/asset-newer-workstream-doc/content',
+                    assetId: 'asset-newer-workstream-doc',
+                    caption: 'Newer workstream doc',
+                    timestamp: '2026-01-01T00:10:00.000Z',
+                }],
+        }, workspaceId);
+        core.upsertInitiativeForSync({
+            ...initiative,
+            title: 'Stale initiative snapshot',
+            updatedAt: '2026-01-01T00:05:00.000Z',
+            attachments: [],
+        }, workspaceId);
+        core.upsertWorkstreamForSync({
+            ...workstream,
+            title: 'Stale workstream snapshot',
+            updatedAt: '2026-01-01T00:05:00.000Z',
+            attachments: [],
+        }, workspaceId);
+        expect(core.getInitiative(initiative.id, workspaceId)).toEqual(expect.objectContaining({
+            title: 'Cloud initiative',
+            updatedAt: '2026-01-01T00:10:00.000Z',
+            attachments: [
+                expect.objectContaining({
+                    assetId: 'asset-newer-initiative-doc',
+                    caption: 'Newer initiative doc',
+                })
+            ],
+        }));
+        expect(core.getWorkstream(workstream.id, workspaceId)).toEqual(expect.objectContaining({
+            title: 'Cloud workstream',
+            updatedAt: '2026-01-01T00:10:00.000Z',
+            attachments: [
+                expect.objectContaining({
+                    assetId: 'asset-newer-workstream-doc',
+                    caption: 'Newer workstream doc',
+                })
+            ],
+        }));
+        core.close();
+    });
     it('builds lightweight planning bootstrap summaries without hydrating full task details', () => {
         const core = createCore();
         const initiative = core.createInitiative({ title: 'Launch initiative' });
@@ -127,6 +487,8 @@ describe('TaskforceCore planning entity persistence', () => {
         const billingSummary = bootstrap.workstreamTaskSummaries.find((entry) => entry.workstreamId === billingWorkstream.id);
         expect(bootstrap.initiatives.map((entry) => entry.id)).toEqual([initiative.id]);
         expect(bootstrap.workstreams.map((entry) => entry.id)).toEqual([deliveryWorkstream.id, billingWorkstream.id]);
+        expect(bootstrap.initiatives.every((entry) => entry.activity === undefined && entry.entityEvents === undefined)).toBe(true);
+        expect(bootstrap.workstreams.every((entry) => entry.activity === undefined && entry.entityEvents === undefined)).toBe(true);
         expect(deliverySummary).toMatchObject({
             workstreamId: deliveryWorkstream.id,
             taskCount: 2,

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;