@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/sync/contentSyncState.js

@@ -1,6 +1,64 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash, randomUUID } from 'crypto';
+function decodeTaskforceContextPath(value, normalizePath) {
+    const normalized = String(value || '').trim();
+    if (!normalized.startsWith('/api/taskforce/context/'))
+        return null;
+    const encoded = normalized.slice('/api/taskforce/context/'.length).split(/[?#]/, 1)[0] || '';
+    if (!encoded)
+        return null;
+    try {
+        return normalizePath(decodeURIComponent(encoded));
+    }
+    catch {
+        return null;
+    }
+}
+function isAiProfileAvatarAssetPath(value, workspaceId) {
+    const normalized = String(value || '').replace(/\\/g, '/');
+    return normalized.startsWith(`workspaces/${workspaceId}/assets/images/ai-profiles/`)
+        && normalized.includes('/avatar/');
+}
+function inferBinaryAssetMimeType(assetPath) {
+    const ext = path.extname(assetPath).toLowerCase();
+    if (ext === '.png')
+        return 'image/png';
+    if (ext === '.jpg' || ext === '.jpeg')
+        return 'image/jpeg';
+    if (ext === '.webp')
+        return 'image/webp';
+    if (ext === '.gif')
+        return 'image/gif';
+    return 'application/octet-stream';
+}
+function inferAssetIdFromPath(assetPath) {
+    const match = String(assetPath || '').match(/(^|\/)(asset-[a-f0-9]{32})(?=[^/]*$)/i);
+    return match?.[2];
+}
+function listReferencedAiProfileAvatarAssetPaths(deps, workspaceId) {
+    const profiles = typeof deps.core.listAiProfiles === 'function'
+        ? deps.core.listAiProfiles(workspaceId, { includeArchived: true })
+        : [];
+    const referenced = new Map();
+    for (const profile of Array.isArray(profiles) ? profiles : []) {
+        const updatedAt = String(profile?.updatedAt || profile?.createdAt || '').trim();
+        for (const url of [profile?.avatarUrl, profile?.avatarSourceUrl]) {
+            const assetPath = decodeTaskforceContextPath(url, deps.normalizeTaskDataRelativePath);
+            if (!assetPath || !isAiProfileAvatarAssetPath(assetPath, workspaceId))
+                continue;
+            if (referenced.has(assetPath))
+                continue;
+            referenced.set(assetPath, {
+                updatedAt,
+                assetId: inferAssetIdFromPath(assetPath),
+                originalFilename: path.basename(assetPath),
+                mimeType: inferBinaryAssetMimeType(assetPath)
+            });
+        }
+    }
+    return referenced;
+}
 export function resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId) {
     if (!deps.workspaceAssetStore) {
         return {
@@ -19,6 +77,28 @@ export function resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId) {
     }
     return { primaryLink, effectiveUpdatedAt };
 }
+function resolveSyncLinkTarget(primaryLink) {
+    if (!primaryLink)
+        return null;
+    const targetId = String(primaryLink.targetId || primaryLink.taskId || '').trim();
+    if (!targetId)
+        return null;
+    const targetType = primaryLink.targetType === 'initiative' || primaryLink.targetType === 'workstream'
+        ? primaryLink.targetType
+        : 'task';
+    return { targetType, targetId };
+}
+function resolveIncomingSyncLinkTarget(input) {
+    const linkTargetType = input.linkTargetType === 'initiative' || input.linkTargetType === 'workstream' || input.linkTargetType === 'task'
+        ? input.linkTargetType
+        : null;
+    const linkTargetId = String(input.linkTargetId || '').trim();
+    if (linkTargetType && linkTargetId) {
+        return { targetType: linkTargetType, targetId: linkTargetId };
+    }
+    const taskId = String(input.taskId || '').trim();
+    return taskId ? { targetType: 'task', targetId: taskId } : null;
+}
 export function getCanonicalSyncDocumentMetadata(deps, relativePath, workspaceId) {
     if (!deps.workspaceAssetStore)
         return {};
@@ -26,19 +106,22 @@ export function getCanonicalSyncDocumentMetadata(deps, relativePath, workspaceId
     if (!asset || asset.kind !== 'document')
         return {};
     const { primaryLink } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+    const linkTarget = resolveSyncLinkTarget(primaryLink);
     return {
         assetId: asset.assetId,
         documentId: asset.documentId,
         referenceNumber: asset.referenceNumber,
         version: asset.version,
-        taskId: primaryLink?.taskId || null,
+        taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+        linkTargetType: linkTarget?.targetType || null,
+        linkTargetId: linkTarget?.targetId || null,
         logicalName: asset.logicalName || null,
         caption: primaryLink?.displayName || null,
         originalFilename: asset.originalFilename || path.basename(relativePath),
         linkRole: primaryLink?.role === 'reference' ? 'reference' : 'attachment'
     };
 }
-export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc, options) {
+export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc) {
     if (!deps.workspaceAssetStore)
         return false;
     const existingAsset = deps.workspaceAssetStore.getByStorageKey(doc.path, workspaceId);
@@ -63,33 +146,23 @@ export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc, options) {
     const normalizedIncomingFilename = typeof doc.originalFilename === 'string' && doc.originalFilename.trim().length > 0
         ? doc.originalFilename.trim()
         : null;
-    const normalizedIncomingTaskId = typeof doc.taskId === 'string' && doc.taskId.trim().length > 0
-        ? doc.taskId.trim()
-        : null;
+    const incomingLinkTarget = resolveIncomingSyncLinkTarget(doc);
+    const primaryLinkTarget = resolveSyncLinkTarget(primaryLink);
     const normalizedIncomingLinkRole = doc.linkRole === 'reference' ? 'reference' : 'attachment';
-    const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true;
     const referenceNumberMismatch = Boolean(existingAsset.referenceNumber
         && normalizedIncomingReference
         && existingAsset.referenceNumber !== normalizedIncomingReference);
-    if (referenceNumberMismatch) {
-        deps.recordSyncDiagnostic(workspaceId, 'apply', 'Detected document reference number mismatch during normal sync.', {
-            source: 'documents.referenceNumber.mismatch',
-            path: doc.path,
-            assetId: existingAsset.assetId,
-            existingReferenceNumber: existingAsset.referenceNumber,
-            incomingReferenceNumber: normalizedIncomingReference
-        });
-    }
-    return (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
+    return referenceNumberMismatch
         || existingAsset.version !== normalizedIncomingVersion
         || (existingAsset.documentId || null) !== normalizedIncomingDocumentId
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
         || (existingAsset.originalFilename || null) !== normalizedIncomingFilename
-        || (primaryLink?.taskId || null) !== normalizedIncomingTaskId
+        || (primaryLinkTarget?.targetType || null) !== (incomingLinkTarget?.targetType || null)
+        || (primaryLinkTarget?.targetId || null) !== (incomingLinkTarget?.targetId || null)
         || (primaryLink?.displayName || null) !== normalizedIncomingCaption
         || ((primaryLink?.role === 'reference' ? 'reference' : 'attachment')) !== normalizedIncomingLinkRole;
 }
-export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset, options) {
+export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset) {
     if (!deps.workspaceAssetStore)
         return false;
     const existingAsset = deps.workspaceAssetStore.getByStorageKey(asset.path, workspaceId);
@@ -108,31 +181,21 @@ export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset, option
     const normalizedIncomingFilename = typeof asset.originalFilename === 'string' && asset.originalFilename.trim().length > 0
         ? asset.originalFilename.trim()
         : null;
-    const normalizedIncomingTaskId = typeof asset.taskId === 'string' && asset.taskId.trim().length > 0
-        ? asset.taskId.trim()
-        : null;
+    const incomingLinkTarget = resolveIncomingSyncLinkTarget(asset);
+    const primaryLinkTarget = resolveSyncLinkTarget(primaryLink);
     const normalizedIncomingLinkRole = asset.linkRole === 'reference'
         ? 'reference'
         : asset.kind === 'image'
             ? 'image'
             : 'attachment';
-    const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true;
     const referenceNumberMismatch = Boolean(existingAsset.referenceNumber
         && normalizedIncomingReference
         && existingAsset.referenceNumber !== normalizedIncomingReference);
-    if (referenceNumberMismatch) {
-        deps.recordSyncDiagnostic(workspaceId, 'apply', 'Detected asset reference number mismatch during normal sync.', {
-            source: 'assets.referenceNumber.mismatch',
-            path: asset.path,
-            assetId: existingAsset.assetId,
-            existingReferenceNumber: existingAsset.referenceNumber,
-            incomingReferenceNumber: normalizedIncomingReference
-        });
-    }
-    return (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
+    return referenceNumberMismatch
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
         || (existingAsset.originalFilename || null) !== normalizedIncomingFilename
-        || (primaryLink?.taskId || null) !== normalizedIncomingTaskId
+        || (primaryLinkTarget?.targetType || null) !== (incomingLinkTarget?.targetType || null)
+        || (primaryLinkTarget?.targetId || null) !== (incomingLinkTarget?.targetId || null)
         || (primaryLink?.displayName || null) !== normalizedIncomingCaption
         || ((primaryLink?.role === 'reference'
             ? 'reference'
@@ -147,7 +210,7 @@ export function reconcileWorkspaceSyncLinks(deps, input) {
     const assetId = String(input.assetId || '').trim();
     if (!assetId)
         return;
-    const desiredTaskId = String(input.taskId || '').trim();
+    const desiredLinkTarget = resolveIncomingSyncLinkTarget(input);
     const desiredRole = input.role === 'reference'
         ? 'reference'
         : input.role === 'image'
@@ -155,27 +218,32 @@ export function reconcileWorkspaceSyncLinks(deps, input) {
             : 'attachment';
     const linkUpdatedAt = String(input.updatedAt || '').trim() || new Date().toISOString();
     const existingLinks = deps.workspaceAssetStore.listLinksForAsset(assetId, workspaceId, { includeDeleted: true });
-    if (desiredTaskId) {
+    if (desiredLinkTarget) {
         deps.workspaceAssetStore.upsertLink({
             workspaceId,
             assetId,
-            taskId: desiredTaskId,
+            targetType: desiredLinkTarget.targetType,
+            targetId: desiredLinkTarget.targetId,
             role: desiredRole,
             displayName: typeof input.displayName === 'string' && input.displayName.trim().length > 0 ? input.displayName.trim() : null,
             updatedAt: linkUpdatedAt,
             deletedAt: null
         });
     }
-    if (desiredTaskId) {
+    if (desiredLinkTarget) {
         for (const link of existingLinks) {
-            if (link.taskId === desiredTaskId && link.role === desiredRole)
+            if (link.targetType === desiredLinkTarget.targetType
+                && link.targetId === desiredLinkTarget.targetId
+                && link.role === desiredRole) {
                 continue;
+            }
             if (link.deletedAt)
                 continue;
             deps.workspaceAssetStore.deleteLink({
                 workspaceId,
                 assetId,
-                taskId: link.taskId,
+                targetType: link.targetType,
+                targetId: link.targetId,
                 role: link.role
             });
         }
@@ -205,26 +273,9 @@ export async function listWorkspaceSyncDocumentsSnapshot(deps, basePath, workspa
     const root = path.resolve(basePath);
     const objectStorageClient = deps.getObjectStorageClient();
     const candidatePaths = new Set();
-    const docsRoot = path.join(root, 'docs');
-    const collectMarkdownPaths = (directory) => {
-        if (!fs.existsSync(directory))
-            return;
-        const entries = fs.readdirSync(directory, { withFileTypes: true });
-        for (const entry of entries) {
-            const absolutePath = path.join(directory, entry.name);
-            if (entry.isDirectory()) {
-                collectMarkdownPaths(absolutePath);
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            const relativeFromRoot = path.relative(root, absolutePath).replace(/\\/g, '/');
-            const normalized = deps.normalizeWorkspaceSyncDocumentPath(relativeFromRoot);
-            if (normalized)
-                candidatePaths.add(normalized);
-        }
-    };
-    collectMarkdownPaths(docsRoot);
+    // Shared document sync is canonical-document-only. Raw .taskforce/docs files
+    // are intentionally excluded because they are not workspace-scoped and must
+    // not re-enter cross-runtime shared document sync.
     if (deps.workspaceAssetStore) {
         const canonicalAssets = deps.workspaceAssetStore.listAllByWorkspace(workspaceId, {
             includeDeleted: false,
@@ -345,28 +396,9 @@ export async function listWorkspaceSyncDocumentsSnapshot(deps, basePath, workspa
     return docs;
 }
 export async function listWorkspaceSyncDocumentIndex(deps, basePath, workspaceId = 'default') {
-    const root = path.resolve(basePath);
     const candidatePaths = new Set();
-    const docsRoot = path.join(root, 'docs');
-    const collectMarkdownPaths = (directory) => {
-        if (!fs.existsSync(directory))
-            return;
-        const entries = fs.readdirSync(directory, { withFileTypes: true });
-        for (const entry of entries) {
-            const absolutePath = path.join(directory, entry.name);
-            if (entry.isDirectory()) {
-                collectMarkdownPaths(absolutePath);
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            const relativeFromRoot = path.relative(root, absolutePath).replace(/\\/g, '/');
-            const normalized = deps.normalizeWorkspaceSyncDocumentPath(relativeFromRoot);
-            if (normalized)
-                candidatePaths.add(normalized);
-        }
-    };
-    collectMarkdownPaths(docsRoot);
+    // Keep the document index aligned with the snapshot invariant above: only
+    // canonical workspace document assets may participate in shared document sync.
     if (deps.workspaceAssetStore) {
         const canonicalAssets = deps.workspaceAssetStore.listAllByWorkspace(workspaceId, {
             includeDeleted: false,
@@ -419,14 +451,13 @@ export async function listWorkspaceSyncDocumentIndex(deps, basePath, workspaceId
     return docs;
 }
 export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, workspaceId = 'default') {
-    if (!deps.workspaceAssetStore)
-        return [];
     const root = path.resolve(basePath);
     const objectStorageClient = deps.getObjectStorageClient();
-    const assets = deps.workspaceAssetStore.listAllByWorkspace(workspaceId, {
+    const assets = deps.workspaceAssetStore?.listAllByWorkspace(workspaceId, {
         includeDeleted: false
-    });
+    }) || [];
     const snapshots = [];
+    const emittedPaths = new Set();
     for (const asset of assets) {
         if (asset.kind !== 'image' && asset.kind !== 'file')
             continue;
@@ -437,6 +468,7 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
             continue;
         if (!deps.normalizeTaskDataRelativePath(storageKey))
             continue;
+        emittedPaths.add(storageKey);
         try {
             let buffer = null;
             if (asset.storageProvider === 'r2' && objectStorageClient) {
@@ -467,6 +499,7 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
                 continue;
             }
             const { primaryLink, effectiveUpdatedAt } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+            const linkTarget = resolveSyncLinkTarget(primaryLink);
             snapshots.push({
                 path: storageKey,
                 updatedAt: effectiveUpdatedAt,
@@ -475,7 +508,9 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
                 kind: asset.kind,
                 mimeType: asset.mimeType || 'application/octet-stream',
                 referenceNumber: asset.referenceNumber,
-                taskId: primaryLink?.taskId || null,
+                taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+                linkTargetType: linkTarget?.targetType || null,
+                linkTargetId: linkTarget?.targetId || null,
                 logicalName: asset.logicalName || null,
                 caption: primaryLink?.displayName || null,
                 originalFilename: asset.originalFilename || path.basename(storageKey),
@@ -490,15 +525,56 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
             });
         }
     }
+    const referencedAiAvatarAssets = listReferencedAiProfileAvatarAssetPaths(deps, workspaceId);
+    for (const [assetPath, metadata] of referencedAiAvatarAssets.entries()) {
+        if (emittedPaths.has(assetPath))
+            continue;
+        const absolutePath = path.resolve(root, assetPath);
+        if (absolutePath === root || !absolutePath.startsWith(`${root}${path.sep}`))
+            continue;
+        try {
+            let buffer = null;
+            if (objectStorageClient) {
+                const object = await objectStorageClient.getObject(assetPath);
+                buffer = object?.body || null;
+            }
+            else if (fs.existsSync(absolutePath)) {
+                buffer = fs.readFileSync(absolutePath);
+            }
+            if (!buffer)
+                continue;
+            snapshots.push({
+                path: assetPath,
+                updatedAt: metadata.updatedAt || new Date().toISOString(),
+                contentBase64: buffer.toString('base64'),
+                ...(metadata.assetId ? { assetId: metadata.assetId } : {}),
+                kind: 'image',
+                mimeType: metadata.mimeType,
+                referenceNumber: null,
+                taskId: null,
+                linkTargetType: null,
+                linkTargetId: null,
+                logicalName: null,
+                caption: null,
+                originalFilename: metadata.originalFilename,
+                linkRole: 'image'
+            });
+        }
+        catch (error) {
+            deps.recordSyncDiagnostic(workspaceId, 'pull', 'Failed to read referenced AI profile avatar asset.', {
+                source: 'assets.snapshot.aiProfileAvatar',
+                path: assetPath,
+                error: String(error?.message || error || '')
+            });
+        }
+    }
     return snapshots;
 }
 export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'default') {
-    if (!deps.workspaceAssetStore)
-        return [];
-    const assets = deps.workspaceAssetStore.listAllByWorkspace(workspaceId, {
+    const assets = deps.workspaceAssetStore?.listAllByWorkspace(workspaceId, {
         includeDeleted: false
-    });
-    return assets
+    }) || [];
+    const indexed = assets
         .filter((asset) => asset.kind === 'image' || asset.kind === 'file')
         .filter((asset) => asset.storageProvider !== 'external')
         .filter((asset) => {
@@ -508,6 +584,7 @@ export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'def
         .map((asset) => {
         const storageKey = String(asset.storageKey || '').trim();
         const { primaryLink, effectiveUpdatedAt } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+        const linkTarget = resolveSyncLinkTarget(primaryLink);
         const assetKind = asset.kind === 'image' ? 'image' : 'file';
         return {
             path: storageKey,
@@ -516,7 +593,9 @@ export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'def
             kind: assetKind,
             mimeType: asset.mimeType || 'application/octet-stream',
             referenceNumber: asset.referenceNumber,
-            taskId: primaryLink?.taskId || null,
+            taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+            linkTargetType: linkTarget?.targetType || null,
+            linkTargetId: linkTarget?.targetId || null,
             logicalName: asset.logicalName || null,
             caption: primaryLink?.displayName || null,
             originalFilename: asset.originalFilename || path.basename(storageKey),
@@ -524,6 +603,29 @@ export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'def
         };
     })
         .filter((entry) => Number.isFinite(Date.parse(entry.updatedAt)) && entry.path.length > 0);
+    const indexedPaths = new Set(indexed.map((entry) => entry.path));
+    for (const [assetPath, metadata] of listReferencedAiProfileAvatarAssetPaths(deps, workspaceId).entries()) {
+        if (indexedPaths.has(assetPath))
+            continue;
+        if (!Number.isFinite(Date.parse(metadata.updatedAt)))
+            continue;
+        indexed.push({
+            path: assetPath,
+            updatedAt: metadata.updatedAt,
+            ...(metadata.assetId ? { assetId: metadata.assetId } : {}),
+            kind: 'image',
+            mimeType: metadata.mimeType,
+            referenceNumber: null,
+            taskId: null,
+            linkTargetType: null,
+            linkTargetId: null,
+            logicalName: null,
+            caption: null,
+            originalFilename: metadata.originalFilename,
+            linkRole: 'image'
+        });
+    }
+    return indexed;
 }
 export async function loadWorkspaceSyncDocumentPayload(deps, basePath, workspaceId, relativePath) {
     const normalizedPath = deps.normalizeWorkspaceSyncDocumentPath(relativePath);
@@ -626,16 +728,18 @@ export async function loadWorkspaceSyncBinaryAssetPayload(deps, basePath, worksp
     const normalizedPath = deps.normalizeTaskDataRelativePath(assetPath);
     if (!normalizedPath)
         return null;
-    if (!deps.workspaceAssetStore)
-        return null;
-    const asset = deps.workspaceAssetStore.getByStorageKey(normalizedPath, workspaceId);
-    if (!asset || (asset.kind !== 'image' && asset.kind !== 'file') || asset.storageProvider === 'external') {
+    const asset = deps.workspaceAssetStore?.getByStorageKey(normalizedPath, workspaceId) || null;
+    const referencedAiAvatar = !asset
+        ? listReferencedAiProfileAvatarAssetPaths(deps, workspaceId).get(normalizedPath) || null
+        : null;
+    if (!referencedAiAvatar
+        && (!asset || (asset.kind !== 'image' && asset.kind !== 'file') || asset.storageProvider === 'external')) {
         return null;
     }
     const objectStorageClient = deps.getObjectStorageClient();
     let buffer = null;
     try {
-        if (asset.storageProvider === 'r2' && objectStorageClient) {
+        if ((asset?.storageProvider === 'r2' || referencedAiAvatar) && objectStorageClient) {
             const object = await objectStorageClient.getObject(normalizedPath);
             buffer = object?.body || null;
         }
@@ -648,28 +752,59 @@ export async function loadWorkspaceSyncBinaryAssetPayload(deps, basePath, worksp
                 return null;
             buffer = fs.readFileSync(absolutePath);
         }
+        if (!buffer && referencedAiAvatar && objectStorageClient) {
+            const root = path.resolve(basePath);
+            const absolutePath = path.resolve(root, normalizedPath);
+            if (absolutePath !== root && absolutePath.startsWith(`${root}${path.sep}`) && fs.existsSync(absolutePath)) {
+                buffer = fs.readFileSync(absolutePath);
+            }
+        }
     }
     catch (error) {
         deps.recordSyncDiagnostic(workspaceId, 'pull', 'Failed to load targeted binary asset payload.', {
             source: 'assets.snapshot.loadPayload',
             path: normalizedPath,
-            assetId: asset.assetId,
+            assetId: asset?.assetId || referencedAiAvatar?.assetId,
             error: String(error?.message || error || '')
         });
         return null;
     }
     if (!buffer)
         return null;
+    if (!asset && referencedAiAvatar) {
+        return {
+            path: normalizedPath,
+            updatedAt: referencedAiAvatar.updatedAt || new Date().toISOString(),
+            contentBase64: buffer.toString('base64'),
+            ...(referencedAiAvatar.assetId ? { assetId: referencedAiAvatar.assetId } : {}),
+            kind: 'image',
+            mimeType: referencedAiAvatar.mimeType,
+            referenceNumber: null,
+            taskId: null,
+            linkTargetType: null,
+            linkTargetId: null,
+            logicalName: null,
+            caption: null,
+            originalFilename: referencedAiAvatar.originalFilename,
+            linkRole: 'image'
+        };
+    }
+    if (!asset)
+        return null;
     const { primaryLink, effectiveUpdatedAt } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+    const linkTarget = resolveSyncLinkTarget(primaryLink);
+    const assetKind = asset.kind === 'image' ? 'image' : 'file';
     return {
         path: normalizedPath,
         updatedAt: effectiveUpdatedAt,
         contentBase64: buffer.toString('base64'),
         assetId: asset.assetId,
-        kind: asset.kind,
+        kind: assetKind,
         mimeType: asset.mimeType || 'application/octet-stream',
         referenceNumber: asset.referenceNumber,
-        taskId: primaryLink?.taskId || null,
+        taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+        linkTargetType: linkTarget?.targetType || null,
+        linkTargetId: linkTarget?.targetId || null,
         logicalName: asset.logicalName || null,
         caption: primaryLink?.displayName || null,
         originalFilename: asset.originalFilename || path.basename(normalizedPath),
@@ -774,11 +909,13 @@ export async function writeWorkspaceSyncDocument(deps, basePath, doc, workspaceI
                 purgeAfter: null,
                 allowReferenceNumberReassignment
             });
-            const taskId = String(doc.taskId || '').trim();
+            const linkTarget = resolveIncomingSyncLinkTarget(doc);
             reconcileWorkspaceSyncLinks(deps, {
                 workspaceId,
                 assetId: asset.assetId,
-                taskId,
+                taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+                linkTargetType: linkTarget?.targetType || null,
+                linkTargetId: linkTarget?.targetId || null,
                 displayName: typeof doc.caption === 'string' && doc.caption.trim().length > 0 ? doc.caption.trim() : null,
                 role: doc.linkRole === 'reference' ? 'reference' : 'attachment',
                 updatedAt: effectiveUpdatedAt
@@ -866,11 +1003,13 @@ export async function writeWorkspaceSyncBinaryAsset(deps, basePath, asset, works
             purgeAfter: null,
             allowReferenceNumberReassignment
         });
-        const taskId = String(asset.taskId || '').trim();
+        const linkTarget = resolveIncomingSyncLinkTarget(asset);
         reconcileWorkspaceSyncLinks(deps, {
             workspaceId,
             assetId: assetRecord.assetId,
-            taskId,
+            taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+            linkTargetType: linkTarget?.targetType || null,
+            linkTargetId: linkTarget?.targetId || null,
             displayName: typeof asset.caption === 'string' && asset.caption.trim().length > 0 ? asset.caption.trim() : null,
             role: asset.linkRole === 'reference' ? 'reference' : asset.kind === 'image' ? 'image' : 'attachment',
             updatedAt: effectiveUpdatedAt
@@ -926,7 +1065,8 @@ export function deleteWorkspaceSyncBinaryAsset(deps, basePath, assetPath, worksp
                 deps.workspaceAssetStore.deleteLink({
                     workspaceId,
                     assetId: existing.assetId,
-                    taskId: link.taskId,
+                    targetType: link.targetType,
+                    targetId: link.targetId,
                     role: link.role
                 });
             }
@@ -976,7 +1116,8 @@ export function deleteWorkspaceSyncDocument(deps, basePath, docPath, workspaceId
                     deps.workspaceAssetStore.deleteLink({
                         workspaceId,
                         assetId: existing.assetId,
-                        taskId: link.taskId,
+                        targetType: link.targetType,
+                        targetId: link.targetId,
                         role: link.role
                     });
                 }
@@ -996,8 +1137,8 @@ export function createContentSyncState(deps) {
     return {
         resolveCanonicalAssetSyncLinkState: (asset, workspaceId) => resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId),
         getCanonicalSyncDocumentMetadata: (relativePath, workspaceId) => getCanonicalSyncDocumentMetadata(deps, relativePath, workspaceId),
-        hasDocumentSyncMetadataDrift: (workspaceId, doc, options) => hasDocumentSyncMetadataDrift(deps, workspaceId, doc, options),
-        hasBinaryAssetSyncMetadataDrift: (workspaceId, asset, options) => hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset, options),
+        hasDocumentSyncMetadataDrift: (workspaceId, doc, _options) => hasDocumentSyncMetadataDrift(deps, workspaceId, doc),
+        hasBinaryAssetSyncMetadataDrift: (workspaceId, asset, _options) => hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset),
         reconcileWorkspaceSyncLinks: (input) => reconcileWorkspaceSyncLinks(deps, input),
         listWorkspaceSyncDocumentDeletesSnapshot: (workspaceId = 'default') => listWorkspaceSyncDocumentDeletesSnapshot(deps, workspaceId),
         listWorkspaceSyncDocumentIndex: (basePath, workspaceId = 'default') => listWorkspaceSyncDocumentIndex(deps, basePath, workspaceId),

package/dist/sync/planningSyncPayload.js

@@ -23,6 +23,9 @@ function toOptionalInteger(value) {
         return null;
     return Math.floor(normalized);
 }
+function clonePlanningAttachments(value) {
+    return Array.isArray(value) ? value : undefined;
+}
 export function normalizeTaxonomySyncPayload(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;
@@ -56,6 +59,7 @@ export function normalizeInitiativeSyncPayload(raw, sourceWatermark) {
         createdAt: String(source.createdAt || sourceWatermark || '').trim(),
         updatedAt: String(source.updatedAt || sourceWatermark || source.createdAt || '').trim(),
         order: toOptionalInteger(source.order),
+        attachments: clonePlanningAttachments(source.attachments),
         isArchived: Boolean(source.isArchived),
     };
 }
@@ -77,6 +81,7 @@ export function normalizeWorkstreamSyncPayload(raw, sourceWatermark) {
         createdAt: String(source.createdAt || sourceWatermark || '').trim(),
         updatedAt: String(source.updatedAt || sourceWatermark || source.createdAt || '').trim(),
         order: toOptionalInteger(source.order),
+        attachments: clonePlanningAttachments(source.attachments),
         isArchived: Boolean(source.isArchived),
     };
 }