@taskforcehq/taskforce 0.3.305 → 0.3.306

package/dist/styles/fonts.css

@@ -0,0 +1,70 @@
+@font-face {
+  font-family: "Russo One";
+  src: url("../assets/fonts/RussoOne-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-Italic.woff2") format("woff2");
+  font-weight: 400;
+  font-style: italic;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-Bold.woff2") format("woff2");
+  font-weight: 700;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-BoldItalic.woff2") format("woff2");
+  font-weight: 700;
+  font-style: italic;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Special Elite";
+  src: url("../assets/fonts/SpecialElite-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Noir";
+  src: url("../assets/fonts/Noir_regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Noir";
+  src: url("../assets/fonts/Noir_medium.woff2") format("woff2");
+  font-weight: 500;
+  font-style: normal;
+  font-display: swap;
+}
+
+:root {
+  --font-brand: "Russo One", sans-serif;
+  --font-typewriter: "Courier Prime", "Courier New", Courier, monospace;
+  --font-stamped: "Special Elite", "Courier Prime", "Courier New", Courier, monospace;
+  --font-noir: "Noir", var(--font-sans, ui-sans-serif, system-ui, sans-serif);
+}

package/dist/sync/collaborationSyncPayload.d.ts

@@ -1,10 +1,15 @@
 import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot } from './workspaceSyncModel.js';
 import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import type { AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 export declare function normalizeAiProfileSyncPayload(raw: unknown, workspaceId: string, normalizeSurfaceType: (value: unknown, context: {
     source: string;
     profileId?: string;
     workspaceId?: string;
-}) => AiProfileSurfaceType | null, source: string): WorkspaceSyncAiProfileSnapshot | null;
+}) => AiProfileSurfaceType | null, normalizeSeatScope: (value: unknown, context: {
+    source: string;
+    profileId?: string;
+    workspaceId?: string;
+}) => AiProfileSeatScope | null, source: string): WorkspaceSyncAiProfileSnapshot | null;
 export declare function normalizeDocumentReviewSessionSyncPayload(raw: unknown, sourceWatermark?: string): WorkspaceSyncDocumentReviewSessionSnapshot | null;
 export declare function normalizeDocumentReviewCommentSyncPayload(raw: unknown, options?: {
     sessionId?: string;

package/dist/sync/collaborationSyncPayload.js

@@ -1,11 +1,9 @@
+import { hasOwnSyncField, normalizeSyncNullableString, normalizeSyncOptionalString, readSyncNullableIdField, readSyncNullableIsoStringField, readSyncNullableStringField, readSyncSameOriginAssetUrlField, } from './syncFieldSemantics.js';
 function toOptionalTrimmedString(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : undefined;
+    return normalizeSyncOptionalString(value);
 }
 function toNullableTrimmedString(value) {
-    return toOptionalTrimmedString(value) ?? null;
+    return normalizeSyncNullableString(value);
 }
 function toOptionalPositiveInteger(value) {
     if (value === undefined || value === null || value === '')
@@ -23,7 +21,7 @@ function toOptionalNonNegativeInteger(value) {
         return 0;
     return Math.max(0, Math.floor(normalized));
 }
-export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurfaceType, source) {
+export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurfaceType, normalizeSeatScope, source) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;
     const profile = raw;
@@ -39,17 +37,25 @@ export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurface
         username: String(profile.username || '').trim(),
         icon: String(profile.icon || 'Bot').trim() || 'Bot',
         color: String(profile.color || '#8b5cf6').trim() || '#8b5cf6',
-        description: toNullableTrimmedString(profile.description),
-        role: toNullableTrimmedString(profile.role),
-        provider: toNullableTrimmedString(profile.provider),
-        model: toNullableTrimmedString(profile.model),
+        ...(hasOwnSyncField(profile, 'avatarUrl') ? { avatarUrl: readSyncSameOriginAssetUrlField(profile, 'avatarUrl') ?? null } : {}),
+        ...(hasOwnSyncField(profile, 'avatarSourceUrl') ? { avatarSourceUrl: readSyncSameOriginAssetUrlField(profile, 'avatarSourceUrl') ?? null } : {}),
+        description: readSyncNullableStringField(profile, 'description') ?? null,
+        role: readSyncNullableStringField(profile, 'role') ?? null,
+        provider: readSyncNullableStringField(profile, 'provider') ?? null,
+        model: readSyncNullableStringField(profile, 'model') ?? null,
         surfaceType: normalizeSurfaceType(profile.surfaceType, { source, profileId, workspaceId: profileWorkspaceId }),
+        seatScope: normalizeSeatScope(profile.seatScope, { source, profileId, workspaceId: profileWorkspaceId }),
         providerMetadata: profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
             ? profile.providerMetadata
             : null,
+        archivedAt: readSyncNullableIsoStringField(profile, 'archivedAt') ?? null,
+        archivedBy: readSyncNullableIdField(profile, 'archivedBy') ?? null,
+        archivedReason: readSyncNullableStringField(profile, 'archivedReason') ?? null,
+        mergedIntoProfileId: readSyncNullableIdField(profile, 'mergedIntoProfileId') ?? null,
+        rosterStateUpdatedAt: readSyncNullableIsoStringField(profile, 'rosterStateUpdatedAt') ?? null,
         createdAt: String(profile.createdAt || '').trim(),
         updatedAt: String(profile.updatedAt || profile.createdAt || '').trim(),
-        lastActiveAt: toNullableTrimmedString(profile.lastActiveAt),
+        lastActiveAt: readSyncNullableIsoStringField(profile, 'lastActiveAt') ?? toNullableTrimmedString(profile.lastActiveAt),
     };
 }
 export function normalizeDocumentReviewSessionSyncPayload(raw, sourceWatermark) {

package/dist/sync/collaborationSyncPayload.test.js

@@ -6,6 +6,11 @@ describe('collaborationSyncPayload', () => {
             return null;
         return String(value).trim();
     };
+    const normalizeSeatScope = (value) => {
+        if (value === undefined || value === null || value === '')
+            return null;
+        return String(value).trim();
+    };
     it('normalizes ai profile sync payloads with workspace and surface type', () => {
         const profile = normalizeAiProfileSyncPayload({
             id: 'profile-1',
@@ -20,11 +25,12 @@ describe('collaborationSyncPayload', () => {
             provider: ' OpenAI ',
             model: ' gpt-5.4 ',
             surfaceType: 'agent',
+            seatScope: 'cloud_metered',
             providerMetadata: { foo: 'bar' },
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             lastActiveAt: '2026-04-10T12:00:00.000Z',
-        }, 'workspace-a', normalizeSurfaceType, 'test.ai');
+        }, 'workspace-a', normalizeSurfaceType, normalizeSeatScope, 'test.ai');
         expect(profile).toEqual({
             id: 'profile-1',
             workspaceId: 'workspace-a',
@@ -38,7 +44,13 @@ describe('collaborationSyncPayload', () => {
             provider: 'OpenAI',
             model: 'gpt-5.4',
             surfaceType: 'agent',
+            seatScope: 'cloud_metered',
             providerMetadata: { foo: 'bar' },
+            archivedAt: null,
+            archivedBy: null,
+            archivedReason: null,
+            mergedIntoProfileId: null,
+            rosterStateUpdatedAt: null,
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             lastActiveAt: '2026-04-10T12:00:00.000Z',

package/dist/sync/contentSyncState.d.ts

@@ -28,12 +28,8 @@ export declare function resolveCanonicalAssetSyncLinkState(deps: ContentSyncStat
     effectiveUpdatedAt: string;
 };
 export declare function getCanonicalSyncDocumentMetadata(deps: ContentSyncStateDeps, relativePath: string, workspaceId: string): Omit<DocumentSyncPayload, 'path' | 'updatedAt' | 'content'>;
-export declare function hasDocumentSyncMetadataDrift(deps: ContentSyncStateDeps, workspaceId: string, doc: DocumentSyncPayload, options?: {
-    allowReferenceNumberReassignment?: boolean;
-}): boolean;
-export declare function hasBinaryAssetSyncMetadataDrift(deps: ContentSyncStateDeps, workspaceId: string, asset: BinaryAssetSyncPayload, options?: {
-    allowReferenceNumberReassignment?: boolean;
-}): boolean;
+export declare function hasDocumentSyncMetadataDrift(deps: ContentSyncStateDeps, workspaceId: string, doc: DocumentSyncPayload): boolean;
+export declare function hasBinaryAssetSyncMetadataDrift(deps: ContentSyncStateDeps, workspaceId: string, asset: BinaryAssetSyncPayload): boolean;
 export declare function reconcileWorkspaceSyncLinks(deps: ContentSyncStateDeps, input: {
     workspaceId: string;
     assetId: string;
@@ -64,10 +60,10 @@ export declare function createContentSyncState(deps: ContentSyncStateDeps): {
         effectiveUpdatedAt: string;
     };
     getCanonicalSyncDocumentMetadata: (relativePath: string, workspaceId: string) => Omit<DocumentSyncPayload, "path" | "updatedAt" | "content">;
-    hasDocumentSyncMetadataDrift: (workspaceId: string, doc: DocumentSyncPayload, options?: {
+    hasDocumentSyncMetadataDrift: (workspaceId: string, doc: DocumentSyncPayload, _options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => boolean;
-    hasBinaryAssetSyncMetadataDrift: (workspaceId: string, asset: BinaryAssetSyncPayload, options?: {
+    hasBinaryAssetSyncMetadataDrift: (workspaceId: string, asset: BinaryAssetSyncPayload, _options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => boolean;
     reconcileWorkspaceSyncLinks: (input: {

package/dist/sync/contentSyncState.js

@@ -38,7 +38,7 @@ export function getCanonicalSyncDocumentMetadata(deps, relativePath, workspaceId
         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);
@@ -67,20 +67,10 @@ export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc, options) {
         ? doc.taskId.trim()
         : null;
     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
@@ -89,7 +79,7 @@ export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc, options) {
         || (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);
@@ -116,20 +106,10 @@ export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset, option
         : 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
@@ -175,7 +155,8 @@ export function reconcileWorkspaceSyncLinks(deps, input) {
             deps.workspaceAssetStore.deleteLink({
                 workspaceId,
                 assetId,
-                taskId: link.taskId,
+                targetType: link.targetType,
+                targetId: link.targetId,
                 role: link.role
             });
         }
@@ -205,26 +186,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 +309,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,
@@ -926,7 +871,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 +922,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 +943,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/syncApplyHandlers.d.ts

@@ -2,6 +2,7 @@ import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
 import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncChange, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncTaskEventSnapshot, WorkspaceSyncTaskSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
 import type { BinaryAssetSyncPayload, DocumentSyncPayload } from './contentSyncPayload.js';
 import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import type { AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 type SyncRouteError = Error & {
     code?: string;
@@ -18,6 +19,11 @@ type NormalizeIncomingAiProfileSurfaceType = (value: unknown, context: {
     profileId?: string;
     workspaceId?: string;
 }) => AiProfileSurfaceType | null;
+type NormalizeIncomingAiProfileSeatScope = (value: unknown, context: {
+    source: string;
+    profileId?: string;
+    workspaceId?: string;
+}) => AiProfileSeatScope | null;
 type NormalizeTaskEventSyncPayload = (raw: unknown, workspaceId: string, sourceWatermark?: string) => WorkspaceSyncTaskEventSnapshot | null;
 export interface WorkspaceSyncIncomingTaskMutation {
     archived: boolean;
@@ -68,6 +74,7 @@ export declare function classifyWorkspaceSyncChanges(input: {
     normalizeWorkspaceSyncDocumentPath: (rawPath: unknown) => string | null;
     normalizeTaskAssetPath: (rawPath: unknown) => string | null;
     normalizeIncomingAiProfileSurfaceType: NormalizeIncomingAiProfileSurfaceType;
+    normalizeIncomingAiProfileSeatScope: NormalizeIncomingAiProfileSeatScope;
     normalizeTaskEventSyncPayload: NormalizeTaskEventSyncPayload;
     recordSyncDiagnostic: RecordSyncDiagnostic;
 }): WorkspaceSyncIncomingApplyModel;

package/dist/sync/syncApplyHandlers.js

@@ -83,7 +83,7 @@ function recordTaskReferenceNumberMismatch(input) {
     return true;
 }
 export function classifyWorkspaceSyncChanges(input) {
-    const { workspaceId, incomingChanges, normalizeWorkspaceSyncDocumentPath, normalizeTaskAssetPath, normalizeIncomingAiProfileSurfaceType, normalizeTaskEventSyncPayload, recordSyncDiagnostic, } = input;
+    const { workspaceId, incomingChanges, normalizeWorkspaceSyncDocumentPath, normalizeTaskAssetPath, normalizeIncomingAiProfileSurfaceType, normalizeIncomingAiProfileSeatScope, normalizeTaskEventSyncPayload, recordSyncDiagnostic, } = input;
     const model = createIncomingApplyModel();
     for (const change of incomingChanges) {
         const raw = change;
@@ -111,7 +111,7 @@ export function classifyWorkspaceSyncChanges(input) {
             continue;
         }
         if (op === 'ai-profile-upsert') {
-            const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, 'apply.aiProfileUpsert');
+            const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, normalizeIncomingAiProfileSeatScope, 'apply.aiProfileUpsert');
             const profileId = String(profile?.id || '').trim();
             if (profileId && profile) {
                 const profileWorkspaceId = String(profile.workspaceId || '').trim();
@@ -382,12 +382,20 @@ export function applyAiProfileAndMemberSyncChanges(input) {
                     username: profile.username,
                     icon: profile.icon,
                     color: profile.color,
+                    ...(Object.prototype.hasOwnProperty.call(profile, 'avatarUrl') ? { avatarUrl: profile.avatarUrl ?? null } : {}),
+                    ...(Object.prototype.hasOwnProperty.call(profile, 'avatarSourceUrl') ? { avatarSourceUrl: profile.avatarSourceUrl ?? null } : {}),
                     description: profile.description ?? null,
                     role: profile.role ?? null,
                     provider: profile.provider ?? null,
                     model: profile.model ?? null,
                     surfaceType: profile.surfaceType,
+                    seatScope: profile.seatScope ?? null,
                     providerMetadata: profile.providerMetadata,
+                    archivedAt: profile.archivedAt ?? null,
+                    archivedBy: profile.archivedBy ?? null,
+                    archivedReason: profile.archivedReason ?? null,
+                    mergedIntoProfileId: profile.mergedIntoProfileId ?? null,
+                    rosterStateUpdatedAt: profile.rosterStateUpdatedAt ?? null,
                     createdAt: profile.createdAt,
                     updatedAt: profile.updatedAt,
                     lastActiveAt: profile.lastActiveAt
@@ -434,14 +442,18 @@ export async function applyContentSyncChanges(input) {
         for (const doc of incomingDocuments) {
             try {
                 const existingDoc = core.getDocumentWatermark(workspaceId, doc.path);
-                const existingDocFallback = getExistingDocument ? getExistingDocument(doc.path, workspaceId) : null;
-                const localDocumentPath = path.resolve(basePath, doc.path);
-                const localDocumentHash = !hasObjectStorageClient() && fs.existsSync(localDocumentPath)
-                    ? createHash('sha256').update(fs.readFileSync(localDocumentPath, 'utf8')).digest('hex')
-                    : '';
+                const existingDocFallback = (!existingDoc && getExistingDocument)
+                    ? getExistingDocument(doc.path, workspaceId)
+                    : null;
                 const incomingHash = createHash('sha256').update(String(doc.content || '')).digest('hex');
                 const existingUpdatedAt = String(existingDoc?.updatedAt || existingDocFallback?.updatedAt || '').trim();
-                const existingHash = String(existingDoc?.contentHash || localDocumentHash || existingDocFallback?.contentHash || '').trim();
+                let existingHash = String(existingDoc?.contentHash || existingDocFallback?.contentHash || '').trim();
+                if (!existingHash && !hasObjectStorageClient()) {
+                    const localDocumentPath = path.resolve(basePath, doc.path);
+                    if (fs.existsSync(localDocumentPath)) {
+                        existingHash = createHash('sha256').update(fs.readFileSync(localDocumentPath, 'utf8')).digest('hex');
+                    }
+                }
                 const compare = resolveSyncConflictOrdering(doc.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 const metadataDrift = hasDocumentSyncMetadataDrift(workspaceId, doc, options);
                 if (compare < 0)
@@ -450,7 +462,9 @@ export async function applyContentSyncChanges(input) {
                     continue;
                 await writeWorkspaceSyncDocument(basePath, doc, workspaceId, {
                     ...options,
-                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true || existingHash !== incomingHash
+                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true
+                        || existingHash !== incomingHash
+                        || metadataDrift
                 });
             }
             catch (error) {
@@ -481,11 +495,11 @@ export async function applyContentSyncChanges(input) {
                 const existing = getExistingBinaryAsset(asset.path, workspaceId);
                 const incomingHash = createHash('sha256').update(Buffer.from(String(asset.contentBase64 || ''), 'base64')).digest('hex');
                 const localFileMissing = !hasObjectStorageClient() && !fs.existsSync(localAssetPath);
-                const localAssetHash = !hasObjectStorageClient() && !localFileMissing
-                    ? createHash('sha256').update(fs.readFileSync(localAssetPath)).digest('hex')
-                    : '';
                 const existingUpdatedAt = String(existing?.updatedAt || '').trim();
-                const existingHash = String(localAssetHash || existing?.contentSha256 || '').trim();
+                let existingHash = String(existing?.contentSha256 || '').trim();
+                if (!existingHash && !hasObjectStorageClient() && !localFileMissing) {
+                    existingHash = createHash('sha256').update(fs.readFileSync(localAssetPath)).digest('hex');
+                }
                 const compare = resolveSyncConflictOrdering(asset.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 const metadataDrift = hasBinaryAssetSyncMetadataDrift(workspaceId, asset, options);
                 if (compare < 0)
@@ -497,6 +511,7 @@ export async function applyContentSyncChanges(input) {
                     allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true
                         || existingHash !== incomingHash
                         || localFileMissing
+                        || metadataDrift
                 });
             }
             catch (error) {

package/dist/sync/syncApplyHandlers.test.js

@@ -1,4 +1,6 @@
-import { describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import { describe, expect, it, vi, afterEach } from 'vitest';
 import { applyCollaborationSyncChanges, applyContentSyncChanges, applyPreparedTaskSyncSnapshot, applyTaskSyncDeletes, classifyWorkspaceSyncChanges, prepareTaskSyncSnapshotApply, } from './syncApplyHandlers.js';
 function createCoreFixture(overrides = {}) {
     return {
@@ -29,6 +31,9 @@ function createCoreFixture(overrides = {}) {
     };
 }
 describe('syncApplyHandlers', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
     it('classifies task and workstream changes, then prepares and applies the task snapshot pipeline', () => {
         const diagnostics = [];
         const workspaceId = 'workspace-1';
@@ -87,6 +92,7 @@ describe('syncApplyHandlers', () => {
             normalizeWorkspaceSyncDocumentPath: (rawPath) => typeof rawPath === 'string' ? rawPath : null,
             normalizeTaskAssetPath: (rawPath) => typeof rawPath === 'string' ? rawPath : null,
             normalizeIncomingAiProfileSurfaceType: () => null,
+            normalizeIncomingAiProfileSeatScope: () => null,
             normalizeTaskEventSyncPayload: () => null,
             recordSyncDiagnostic: (targetWorkspaceId, eventType, message, details) => {
                 diagnostics.push({ workspaceId: targetWorkspaceId, eventType, message, details });
@@ -231,7 +237,7 @@ describe('syncApplyHandlers', () => {
         expect(core.notifyDocumentMetadataMutation).toHaveBeenNthCalledWith(1, 'workspace-1', ['docs/spec.md', 'assets/proof.png'], 'upsert');
         expect(core.notifyDocumentMetadataMutation).toHaveBeenNthCalledWith(2, 'workspace-1', ['docs/stale.md', 'assets/stale.png'], 'delete');
     });
-    it('only allows reference reassignment for content writes when the content changed or repair is explicit', async () => {
+    it('allows reference reassignment when metadata drift requires normal sync convergence', async () => {
         const core = createCoreFixture({
             getDocumentWatermark: vi.fn().mockReturnValue(null),
         });
@@ -280,9 +286,70 @@ describe('syncApplyHandlers', () => {
             }),
             recordSyncDiagnostic: vi.fn(),
         });
-        expect(writeWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'docs/spec.md' }), 'workspace-1', { allowReferenceNumberReassignment: false });
+        expect(writeWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'docs/spec.md' }), 'workspace-1', { allowReferenceNumberReassignment: true });
         expect(writeWorkspaceSyncBinaryAsset).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'assets/proof.png' }), 'workspace-1', { allowReferenceNumberReassignment: true });
     });
+    it('reuses persisted content hashes instead of re-reading unchanged local files', async () => {
+        const existingDocContent = '# Spec';
+        const existingAssetBytes = Buffer.from('png-bytes');
+        const core = createCoreFixture({
+            getDocumentWatermark: vi.fn().mockReturnValue({
+                updatedAt: '2026-04-10T10:00:00.000Z',
+                contentHash: createHash('sha256').update(existingDocContent).digest('hex'),
+            }),
+        });
+        const writeWorkspaceSyncDocument = vi.fn().mockResolvedValue(undefined);
+        const writeWorkspaceSyncBinaryAsset = vi.fn().mockResolvedValue(undefined);
+        const readSpy = vi.spyOn(fs, 'readFileSync').mockImplementation(((targetPath) => {
+            const value = String(targetPath);
+            if (value.endsWith('spec.md'))
+                return existingDocContent;
+            return existingAssetBytes;
+        }));
+        await applyContentSyncChanges({
+            core,
+            workspaceId: 'workspace-1',
+            incomingDocuments: [
+                {
+                    path: 'docs/spec.md',
+                    updatedAt: '2026-04-10T10:00:00.000Z',
+                    content: existingDocContent,
+                    assetId: 'asset-doc-1',
+                },
+            ],
+            incomingDocumentDeletes: new Map(),
+            incomingAssets: [
+                {
+                    path: 'assets/proof.png',
+                    updatedAt: '2026-04-10T10:05:00.000Z',
+                    contentBase64: existingAssetBytes.toString('base64'),
+                    assetId: 'asset-image-1',
+                    kind: 'image',
+                    mimeType: 'image/png',
+                },
+            ],
+            incomingAssetDeletes: new Map(),
+            basePath: '/tmp/taskforce-sync-content',
+            hasObjectStorageClient: () => true,
+            hasDocumentSyncMetadataDrift: () => false,
+            hasBinaryAssetSyncMetadataDrift: () => false,
+            getExistingDocument: () => {
+                throw new Error('document fallback should not be used when persisted metadata exists');
+            },
+            writeWorkspaceSyncDocument,
+            deleteWorkspaceSyncDocument: vi.fn(),
+            writeWorkspaceSyncBinaryAsset,
+            deleteWorkspaceSyncBinaryAsset: vi.fn(),
+            getExistingBinaryAsset: () => ({
+                updatedAt: '2026-04-10T10:05:00.000Z',
+                contentSha256: createHash('sha256').update(existingAssetBytes).digest('hex'),
+            }),
+            recordSyncDiagnostic: vi.fn(),
+        });
+        expect(readSpy).not.toHaveBeenCalled();
+        expect(writeWorkspaceSyncDocument).not.toHaveBeenCalled();
+        expect(writeWorkspaceSyncBinaryAsset).not.toHaveBeenCalled();
+    });
     it('applies collaboration upserts and deletes through the collaboration handlers', () => {
         const core = createCoreFixture();
         applyCollaborationSyncChanges({

package/dist/sync/syncFieldSemantics.d.ts

@@ -0,0 +1,12 @@
+export declare function hasOwnSyncField(source: unknown, field: string): boolean;
+export declare function normalizeSyncOptionalString(value: unknown): string | undefined;
+export declare function normalizeSyncNullableString(value: unknown): string | null;
+export declare function normalizeSyncOptionalId(value: unknown): string | undefined;
+export declare function normalizeSyncNullableId(value: unknown): string | null;
+export declare function normalizeSyncNullableIsoString(value: unknown): string | null;
+export declare function normalizeSyncSameOriginAssetUrl(value: unknown): string | null;
+export declare function readSyncOptionalStringField(source: Record<string, unknown>, field: string): string | undefined;
+export declare function readSyncNullableStringField(source: Record<string, unknown>, field: string): string | null | undefined;
+export declare function readSyncNullableIdField(source: Record<string, unknown>, field: string): string | null | undefined;
+export declare function readSyncNullableIsoStringField(source: Record<string, unknown>, field: string): string | null | undefined;
+export declare function readSyncSameOriginAssetUrlField(source: Record<string, unknown>, field: string): string | null | undefined;