@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/core/PlanFeatureCatalog.test.js

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { TaskforceCore } from './Taskforce';
+function makeProjectRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-plan-feature-catalog-'));
+}
+describe('TaskforceCore plan feature catalog marketing copy', () => {
+    it('persists public marketing copy overrides and falls back after clearing them', () => {
+        const projectRoot = makeProjectRoot();
+        const core = new TaskforceCore({
+            projectRoot,
+            storagePath: path.join(projectRoot, '.taskforce')
+        });
+        const initialFeature = core.listPlanFeatureCatalog().find((feature) => feature.featureKey === 'collaboration.ai_profiles');
+        expect(initialFeature?.label).toBe('AI Profiles');
+        expect(initialFeature?.publicLabel ?? null).toBeNull();
+        expect(initialFeature?.publicDescription ?? null).toBeNull();
+        expect(initialFeature?.publicDisplayOrder).toBe(20);
+        const updated = core.updatePlanFeatureCatalogMarketingCopy({
+            featureKey: 'collaboration.ai_profiles',
+            publicLabel: 'AI teammates',
+            publicDescription: 'Add reusable AI teammates to your workspace.',
+            publicDisplayOrder: 24
+        });
+        expect(updated.publicLabel).toBe('AI teammates');
+        expect(updated.publicDescription).toBe('Add reusable AI teammates to your workspace.');
+        expect(updated.publicDisplayOrder).toBe(24);
+        const persisted = core.listPlanFeatureCatalog().find((feature) => feature.featureKey === 'collaboration.ai_profiles');
+        expect(persisted?.publicLabel).toBe('AI teammates');
+        expect(persisted?.publicDescription).toBe('Add reusable AI teammates to your workspace.');
+        expect(persisted?.publicDisplayOrder).toBe(24);
+        const cleared = core.updatePlanFeatureCatalogMarketingCopy({
+            featureKey: 'collaboration.ai_profiles',
+            publicLabel: '   ',
+            publicDescription: '',
+            publicDisplayOrder: null
+        });
+        expect(cleared.publicLabel ?? null).toBeNull();
+        expect(cleared.publicDescription ?? null).toBeNull();
+        expect(cleared.publicDisplayOrder).toBe(20);
+        const fallback = core.listPlanFeatureCatalog().find((feature) => feature.featureKey === 'collaboration.ai_profiles');
+        expect(fallback?.label).toBe('AI Profiles');
+        expect(fallback?.publicLabel ?? null).toBeNull();
+        expect(fallback?.publicDescription ?? null).toBeNull();
+        expect(fallback?.publicDisplayOrder).toBe(20);
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('migrates legacy workspace feature catalog overrides to the canonical key', () => {
+        const projectRoot = makeProjectRoot();
+        const core = new TaskforceCore({
+            projectRoot,
+            storagePath: path.join(projectRoot, '.taskforce')
+        });
+        const db = core.db;
+        db.prepare(`
+            INSERT INTO plan_feature_catalog_overrides (
+                tenant_id,
+                feature_key,
+                public_label,
+                public_description,
+                public_display_order,
+                created_at,
+                updated_at
+            ) VALUES (?, 'workspace.switching', ?, ?, ?, ?, ?)
+        `).run('default', 'Workspace access', 'Let a user create and switch between multiple workspaces.', 14, '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z');
+        core.planEntitlementService.normalizeLegacyPlanDataIfNeeded();
+        const feature = core.listPlanFeatureCatalog().find((item) => item.featureKey === 'workspace.workspaces');
+        expect(feature?.publicLabel).toBe('Workspace access');
+        expect(feature?.publicDescription).toBe('Let a user create and switch between multiple workspaces.');
+        expect(feature?.publicDisplayOrder).toBe(14);
+        const rows = db.prepare(`
+            SELECT feature_key
+            FROM plan_feature_catalog_overrides
+            WHERE tenant_id = ?
+        `).all('default');
+        expect(rows.some((row) => row.feature_key === 'workspace.switching')).toBe(false);
+        expect(rows.some((row) => row.feature_key === 'workspace.workspaces')).toBe(true);
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+});

package/dist/core/PlanVersionPolicy.test.js

@@ -141,11 +141,11 @@ describe('TaskforceCore plan version policy', () => {
             const version = core.updatePlanVersionFeatures({
                 planVersionId: 'free-v1',
                 features: [
-                    { featureKey: 'workspace.switching', access: 'limited', config: { maxWorkspaces: 0 } },
+                    { featureKey: 'workspace.workspaces', access: 'limited', config: { maxWorkspaces: 0 } },
                     { featureKey: 'context.uploads', access: 'limited', config: { storageLimitMb: -50 } }
                 ]
             });
-            expect(version.features['workspace.switching']?.config).toEqual({ maxWorkspaces: 1 });
+            expect(version.features['workspace.workspaces']?.config).toEqual({ maxWorkspaces: 1 });
             expect(version.features['context.uploads']?.config).toEqual({ storageLimitMb: 1 });
         }
         finally {
@@ -153,6 +153,39 @@ describe('TaskforceCore plan version policy', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('migrates legacy workspace feature keys to the canonical key', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.updatePlanVersionFeatures({
+                planVersionId: 'free-v1',
+                features: [
+                    { featureKey: 'workspace.workspaces', access: 'limited', config: { maxWorkspaces: 1 } }
+                ]
+            });
+            const db = core.db;
+            db.prepare(`
+                UPDATE plan_feature_matrix
+                SET feature_key = 'workspace.switching'
+                WHERE tenant_id = ? AND plan_version_id = ? AND feature_key = 'workspace.workspaces'
+            `).run('default', 'free-v1');
+            core.planEntitlementService.normalizeLegacyPlanDataIfNeeded();
+            const version = core.getPlanVersionFeatures('free', 'free-v1');
+            expect(version.features['workspace.workspaces']).toBeTruthy();
+            expect(version.features['workspace.switching']).toBeUndefined();
+            const rows = db.prepare(`
+                SELECT feature_key
+                FROM plan_feature_matrix
+                WHERE tenant_id = ? AND plan_version_id = ?
+            `).all('default', 'free-v1');
+            expect(rows.some((row) => row.feature_key === 'workspace.switching')).toBe(false);
+            expect(rows.some((row) => row.feature_key === 'workspace.workspaces')).toBe(true);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('starts new plans disabled before pricing is configured', () => {
         const projectRoot = makeProjectRoot();
         const core = openCore(projectRoot);

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,4 +130,380 @@ 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' });
+        const deliveryWorkstream = core.createWorkstream({
+            title: 'Delivery',
+            initiativeId: initiative.id,
+        });
+        const billingWorkstream = core.createWorkstream({
+            title: 'Billing',
+            initiativeId: initiative.id,
+        });
+        core.createTask({
+            title: 'Ship onboarding copy',
+            workstreamId: deliveryWorkstream.id,
+            status: 'task',
+        });
+        core.createTask({
+            title: 'Review launch checklist',
+            workstreamId: deliveryWorkstream.id,
+            status: 'done',
+        });
+        core.createTask({
+            title: 'Update billing note',
+            workstreamId: billingWorkstream.id,
+            status: 'cancelled',
+        });
+        core.createTask({
+            title: 'Unlinked task',
+            status: 'task',
+        });
+        const bootstrap = core.listPlanningBootstrap();
+        const deliverySummary = bootstrap.workstreamTaskSummaries.find((entry) => entry.workstreamId === deliveryWorkstream.id);
+        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,
+            completedTaskCount: 1,
+        });
+        expect(deliverySummary?.tasks).toEqual(expect.arrayContaining([
+            expect.objectContaining({ title: 'Ship onboarding copy', status: 'task' }),
+            expect.objectContaining({ title: 'Review launch checklist', status: 'done' }),
+        ]));
+        expect(billingSummary).toMatchObject({
+            workstreamId: billingWorkstream.id,
+            taskCount: 1,
+            completedTaskCount: 1,
+        });
+        expect(bootstrap.workstreamTaskSummaries.some((entry) => entry.tasks.some((task) => task.title === 'Unlinked task'))).toBe(false);
+        core.close();
+    });
 });