@taskforcehq/taskforce 0.3.306 → 0.3.307

package/dist/core/AttachmentLinkService.d.ts

@@ -2,6 +2,7 @@ import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
 export type AttachmentLinkInput = string | {
     path: string;
     fsPath?: string;
+    assetId?: string | null;
     caption?: string;
     displayName?: string;
     originalFilename?: string;
@@ -12,4 +13,6 @@ export interface AttachmentLinkServiceDeps {
     tenantId: string;
     normalizeWorkspaceId: (workspaceId: string) => string;
 }
+export type AttachmentLinkTargetType = 'task' | 'initiative' | 'workstream';
+export declare function syncCanonicalAttachmentLinksForTargetService(deps: AttachmentLinkServiceDeps, targetType: AttachmentLinkTargetType, targetId: string, workspaceId: string, attachments: AttachmentLinkInput[]): void;
 export declare function syncCanonicalTaskAttachmentLinksService(deps: AttachmentLinkServiceDeps, taskId: string, workspaceId: string, attachments: AttachmentLinkInput[]): void;

package/dist/core/AttachmentLinkService.js

@@ -63,6 +63,25 @@ function normalizeAttachmentStorageKey(pathValue, fsPathValue) {
     }
     return null;
 }
+function extractAttachmentAssetId(attachment) {
+    const explicitAssetId = typeof attachment === 'string'
+        ? ''
+        : String(attachment.assetId || '').trim();
+    if (explicitAssetId)
+        return explicitAssetId;
+    const pathValue = typeof attachment === 'string'
+        ? attachment.trim()
+        : String(attachment.path || '').trim();
+    const match = pathValue.match(/^\/api\/taskforce\/documents\/([^/?#]+)\/content(?:[?#].*)?$/);
+    if (!match)
+        return null;
+    try {
+        return decodeURIComponent(match[1]).trim() || null;
+    }
+    catch {
+        return match[1].trim() || null;
+    }
+}
 function ensureExternalReferenceAsset(deps, storageKeyRaw, workspaceId, attachment) {
     const storageKey = String(storageKeyRaw || '').trim();
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
@@ -124,25 +143,31 @@ function ensureExternalReferenceAsset(deps, storageKeyRaw, workspaceId, attachme
     `).run(assetId, deps.tenantId, normalizedWorkspaceId, 'file', logicalName, logicalName, mimeType, 'external', storageKey, urlHash, Buffer.byteLength(storageKey, 'utf8'), null, null, 1, 'clean', null, null, null, timestamp, timestamp);
     return assetId;
 }
-export function syncCanonicalTaskAttachmentLinksService(deps, taskId, workspaceId, attachments) {
-    const normalizedTaskId = String(taskId || '').trim();
+export function syncCanonicalAttachmentLinksForTargetService(deps, targetType, targetId, workspaceId, attachments) {
+    const normalizedTargetId = String(targetId || '').trim();
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
-    if (!normalizedTaskId)
+    if (!normalizedTargetId)
         return;
     const supportsTargetType = supportsWorkspaceAssetLinkTargetType(deps.db);
+    const safeTargetType = targetType === 'initiative' || targetType === 'workstream'
+        ? targetType
+        : 'task';
+    const nowIso = new Date().toISOString();
     if (supportsTargetType) {
         deps.db.prepare(`
             UPDATE workspace_asset_links
             SET deleted_at = ?, updated_at = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND target_type = 'task' AND task_id = ? AND deleted_at IS NULL
-        `).run(new Date().toISOString(), new Date().toISOString(), deps.tenantId, normalizedWorkspaceId, normalizedTaskId);
+            WHERE tenant_id = ? AND workspace_id = ? AND target_type = ? AND task_id = ? AND deleted_at IS NULL
+        `).run(nowIso, nowIso, deps.tenantId, normalizedWorkspaceId, safeTargetType, normalizedTargetId);
     }
     else {
+        if (safeTargetType !== 'task')
+            return;
         deps.db.prepare(`
             UPDATE workspace_asset_links
             SET deleted_at = ?, updated_at = ?
             WHERE tenant_id = ? AND workspace_id = ? AND task_id = ? AND deleted_at IS NULL
-        `).run(new Date().toISOString(), new Date().toISOString(), deps.tenantId, normalizedWorkspaceId, normalizedTaskId);
+        `).run(nowIso, nowIso, deps.tenantId, normalizedWorkspaceId, normalizedTargetId);
     }
     const selectAsset = deps.db.prepare(`
         SELECT asset_id, kind
@@ -150,11 +175,17 @@ export function syncCanonicalTaskAttachmentLinksService(deps, taskId, workspaceI
         WHERE tenant_id = ? AND workspace_id = ? AND storage_key = ? AND deleted_at IS NULL
         LIMIT 1
     `);
+    const selectAssetById = deps.db.prepare(`
+        SELECT asset_id, kind
+        FROM workspace_assets
+        WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND deleted_at IS NULL
+        LIMIT 1
+    `);
     const upsertLink = supportsTargetType
         ? deps.db.prepare(`
             INSERT INTO workspace_asset_links (
                 tenant_id, workspace_id, asset_id, target_type, task_id, role, display_name, sort_order, created_at, updated_at, deleted_at
-            ) VALUES (?, ?, ?, 'task', ?, ?, ?, ?, ?, ?, NULL)
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
             ON CONFLICT (tenant_id, workspace_id, asset_id, task_id, role) DO UPDATE SET
                 target_type = excluded.target_type,
                 display_name = excluded.display_name,
@@ -174,16 +205,27 @@ export function syncCanonicalTaskAttachmentLinksService(deps, taskId, workspaceI
         `);
     attachments.forEach((attachment, index) => {
         const storageKey = normalizeAttachmentStorageKey(typeof attachment === 'string' ? attachment : attachment.path, typeof attachment === 'string' ? null : attachment.fsPath);
-        if (!storageKey)
+        const attachmentAssetId = extractAttachmentAssetId(attachment);
+        if (!storageKey && !attachmentAssetId)
             return;
-        const row = selectAsset.get(deps.tenantId, normalizedWorkspaceId, storageKey);
+        const row = (storageKey
+            ? selectAsset.get(deps.tenantId, normalizedWorkspaceId, storageKey)
+            : null)
+            || (attachmentAssetId
+                ? selectAssetById.get(deps.tenantId, normalizedWorkspaceId, attachmentAssetId)
+                : null);
+        const isExternalStorageKey = typeof storageKey === 'string' && /^https?:\/\//i.test(storageKey);
+        const hasExplicitFileStorageKey = typeof storageKey === 'string'
+            && typeof attachment !== 'string'
+            && typeof attachment.fsPath === 'string'
+            && attachment.fsPath.trim().length > 0;
         const assetId = String(row?.asset_id || '').trim()
-            || ((/^https?:\/\//i.test(storageKey) || (typeof attachment !== 'string' && typeof attachment.fsPath === 'string' && attachment.fsPath.trim().length > 0))
+            || (isExternalStorageKey || hasExplicitFileStorageKey
                 ? ensureExternalReferenceAsset(deps, storageKey, normalizedWorkspaceId, attachment)
                 : '');
         if (!assetId)
             return;
-        const role = /^https?:\/\//i.test(storageKey)
+        const role = isExternalStorageKey
             ? 'reference'
             : String(row?.kind || '').trim() === 'image'
                 ? 'image'
@@ -192,8 +234,11 @@ export function syncCanonicalTaskAttachmentLinksService(deps, taskId, workspaceI
             ? null
             : (typeof attachment === 'string'
                 ? null
-                : buildAttachmentDisplayName(attachment, /^https?:\/\//i.test(storageKey) ? null : path.basename(storageKey)));
+                : buildAttachmentDisplayName(attachment, isExternalStorageKey || !storageKey ? null : path.basename(storageKey)));
         const timestamp = typeof attachment === 'string' ? new Date().toISOString() : (attachment.timestamp || new Date().toISOString());
-        upsertLink.run(deps.tenantId, normalizedWorkspaceId, assetId, normalizedTaskId, role, displayName, index, timestamp, timestamp);
+        upsertLink.run(deps.tenantId, normalizedWorkspaceId, assetId, safeTargetType, normalizedTargetId, role, displayName, index, timestamp, timestamp);
     });
 }
+export function syncCanonicalTaskAttachmentLinksService(deps, taskId, workspaceId, attachments) {
+    syncCanonicalAttachmentLinksForTargetService(deps, 'task', taskId, workspaceId, attachments);
+}

package/dist/core/GlobalSettingsService.js

@@ -194,6 +194,12 @@ export function getGlobalSettingsService(deps) {
                         : {}),
                     ...(typeof global.site.pricingPageEnabled === 'boolean'
                         ? { pricingPageEnabled: global.site.pricingPageEnabled }
+                        : {}),
+                    ...(typeof global.site.animatedBackgroundEnabled === 'boolean'
+                        ? { animatedBackgroundEnabled: global.site.animatedBackgroundEnabled }
+                        : {}),
+                    ...(global.site.siteTheme === 'light' || global.site.siteTheme === 'dark'
+                        ? { siteTheme: global.site.siteTheme }
                         : {})
                 }
             }
@@ -407,6 +413,12 @@ export function updateGlobalSettingsService(deps, settings) {
                 : {}),
             ...(typeof incoming.pricingPageEnabled === 'boolean'
                 ? { pricingPageEnabled: incoming.pricingPageEnabled }
+                : {}),
+            ...(typeof incoming.animatedBackgroundEnabled === 'boolean'
+                ? { animatedBackgroundEnabled: incoming.animatedBackgroundEnabled }
+                : {}),
+            ...(incoming.siteTheme === 'light' || incoming.siteTheme === 'dark'
+                ? { siteTheme: incoming.siteTheme }
                 : {})
         };
     }

package/dist/core/McpTokenService.d.ts

@@ -60,6 +60,11 @@ export declare class McpTokenService {
         workspaceId: string;
         tokenId: string;
     }): McpAccessTokenRecord;
+    deleteMcpAccessToken(input: {
+        actorUserId: string;
+        workspaceId: string;
+        tokenId: string;
+    }): boolean;
     regenerateMcpAccessToken(input: {
         actorUserId: string;
         workspaceId: string;
@@ -111,6 +116,13 @@ export declare class McpTokenService {
         grantId: string;
     }): McpOAuthConnectorGrantRecord;
     authenticateMcpOAuthAccessToken(token: string, workspaceId?: string): McpOAuthAccessTokenAuthResult | null;
+    bindMcpOAuthConnectorGrantAiProfile(input: {
+        grantId: string;
+        workspaceId: string;
+        profileId: string;
+        profileToken: string;
+        profileName: string;
+    }): boolean;
     recordMcpOAuthConnectorGrantUsage(input: {
         grantId: string;
         workspaceId: string;

package/dist/core/McpTokenService.js

@@ -518,6 +518,23 @@ export class McpTokenService {
         }
         return this.rowToMcpAccessTokenRecord(updated);
     }
+    deleteMcpAccessToken(input) {
+        this.getActiveWorkspaceMemberForMcp(input.actorUserId, input.workspaceId);
+        const row = this.getMcpAccessTokenRow(input.tokenId, input.workspaceId);
+        if (!row) {
+            throw new TaskforceRuleError('MCP token not found', 404, 'MCP_TOKEN_NOT_FOUND');
+        }
+        this.assertCanManageOwnMcpAccessToken(input.actorUserId, row);
+        const status = this.resolveMcpAccessTokenStatus(row);
+        if (status === 'active') {
+            throw new TaskforceRuleError('Active MCP tokens must be revoked before deletion', 400, 'MCP_TOKEN_DELETE_ACTIVE');
+        }
+        const result = this.db.prepare(`
+            DELETE FROM mcp_access_tokens
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        `).run(this.tenantId, input.workspaceId, row.id);
+        return Number(result.changes || 0) > 0;
+    }
     regenerateMcpAccessToken(input) {
         this.getActiveWorkspaceMemberForMcp(input.actorUserId, input.workspaceId);
         const existing = this.getMcpAccessTokenRow(input.tokenId, input.workspaceId);
@@ -872,7 +889,8 @@ export class McpTokenService {
         if (!parsed)
             return null;
         const row = this.db.prepare(`
-            SELECT id, provider, client_id, user_id, workspace_id, scopes_json, token_hash, status, revoked_at
+            SELECT id, provider, client_id, user_id, workspace_id, scopes_json, token_hash, status, revoked_at,
+                   ai_profile_id, ai_profile_token, ai_profile_name
             FROM mcp_oauth_connector_grants
             WHERE tenant_id = ?
               AND token_prefix = ?
@@ -902,8 +920,33 @@ export class McpTokenService {
             provider: this.normalizeMcpOAuthProvider(row.provider),
             scopes,
             status: this.resolveMcpOAuthGrantStatus(row),
+            aiProfileId: row?.ai_profile_id ? String(row.ai_profile_id) : null,
+            aiProfileToken: row?.ai_profile_token ? String(row.ai_profile_token) : null,
+            aiProfileName: row?.ai_profile_name ? String(row.ai_profile_name) : null,
         };
     }
+    bindMcpOAuthConnectorGrantAiProfile(input) {
+        const grantId = String(input.grantId || '').trim();
+        const workspaceId = String(input.workspaceId || '').trim();
+        const profileId = String(input.profileId || '').trim();
+        const profileToken = String(input.profileToken || '').trim();
+        const profileName = String(input.profileName || '').trim();
+        if (!grantId || !workspaceId || !profileId || !profileToken || !profileName)
+            return false;
+        const now = new Date().toISOString();
+        const result = this.db.prepare(`
+            UPDATE mcp_oauth_connector_grants
+            SET ai_profile_id = ?,
+                ai_profile_token = ?,
+                ai_profile_name = ?,
+                updated_at = ?
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND id = ?
+              AND status = 'active'
+        `).run(profileId, profileToken, profileName, now, this.tenantId, workspaceId, grantId);
+        return Number(result?.changes || 0) > 0;
+    }
     recordMcpOAuthConnectorGrantUsage(input) {
         const grantId = String(input.grantId || '').trim();
         const workspaceId = String(input.workspaceId || '').trim();

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,