@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/sync/workspacePullFeed.js

@@ -1,8 +1,41 @@
 import { serializeTaskForSync } from './taskSyncPayload.js';
+import { normalizeInitiativeSyncPayload, serializeInitiativeForSync } from './planningSyncPayload.js';
+import { fingerprintWorkspaceSyncPayload, WorkspaceSyncDurabilityStore, } from './v3/syncDurabilityStore.js';
+import { serializeTaxonomyStateForSync } from './v3/taxonomySyncPayload.js';
+import { WORKSPACE_CONTENT_MANIFEST_VERSION, createWorkspaceContentMetadataFingerprintV1, } from './workspaceContentManifest.js';
 import { aiProfileSyncResourceAdapter, taskSyncResourceAdapter } from './syncResourceAdapters.js';
+function compareUtf8CursorText(left, right) {
+    return Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8'));
+}
+export const DEFAULT_WORKSPACE_PULL_PAGE_MAX_BYTES = 40 * 1024 * 1024;
+export class WorkspacePullEntryTooLargeError extends Error {
+    statusCode = 413;
+    code = 'WORKSPACE_SYNC_ENTRY_TOO_LARGE';
+    details;
+    constructor(entry, entryBytes, maxPageBytes) {
+        super(`Workspace sync entry ${entry.sortId} exceeds the ${maxPageBytes}-byte pull page limit.`);
+        this.name = 'WorkspacePullEntryTooLargeError';
+        this.details = {
+            entryKind: entry.kind,
+            entryId: entry.sortId,
+            entryBytes,
+            maxPageBytes,
+        };
+    }
+}
 export async function buildWorkspacePullFeed(input) {
     const buildStartedAtMs = Date.now();
     const { core, workspaceId, cursor, pageSize, encodeWorkspaceSyncCursor, contentSyncState, collaborationSyncState } = input;
+    const maxPageBytes = Number.isFinite(Number(input.maxPageBytes)) && Number(input.maxPageBytes) > 0
+        ? Math.floor(Number(input.maxPageBytes))
+        : DEFAULT_WORKSPACE_PULL_PAGE_MAX_BYTES;
+    const contentMode = input.contentMode === 'manifest' ? 'manifest' : 'full';
+    const excludedProjections = new Set(input.excludedProjections || []);
+    const commentsV3Owned = excludedProjections.has('task-comments/full-v1');
+    const checklistV3Owned = excludedProjections.has('task-checklist/full-v1');
+    const attachmentsV3Owned = excludedProjections.has('task-attachment-links/full-v1');
+    const suppressTaskCarriers = excludedProjections.has('task/root-v1')
+        && commentsV3Owned && checklistV3Owned && attachmentsV3Owned;
     const syncCursor = cursor ? { watermark: cursor.u, id: cursor.id } : null;
     const dbFetchLimit = pageSize * 2 + 10;
     const snapshotErrors = [];
@@ -30,57 +63,188 @@ export async function buildWorkspacePullFeed(input) {
             return fallback;
         }
     };
-    const taskRows = core.listTasksForSync(workspaceId, syncCursor, dbFetchLimit);
+    const taskRows = suppressTaskCarriers ? [] : core.listTasksForSync(workspaceId, syncCursor, dbFetchLimit);
+    const durabilityStore = typeof core.getDatabaseAdapter === 'function' && typeof core.getTenantId === 'function'
+        ? new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter())
+        : null;
+    const taskRevisionById = new Map((durabilityStore?.listTaskRevisionProjections({
+        tenantId: core.getTenantId(),
+        workspaceId,
+        taskIds: taskRows.map((entry) => String(entry.task?.id || '').trim()).filter(Boolean),
+    }) || []).map((entry) => [entry.taskId, entry]));
     const upsertEntries = taskRows
         .map((entry) => {
         const watermark = taskSyncResourceAdapter.getWatermark(entry.task);
         const taskId = String(entry.task?.id || '').trim();
+        const task = serializeTaskForSync(entry.task);
+        if (commentsV3Owned)
+            delete task.comments;
+        if (checklistV3Owned)
+            delete task.checklistItems;
+        if (attachmentsV3Owned)
+            delete task.attachments;
+        const ownership = taskRevisionById.get(taskId);
+        let durableRevision;
+        if (ownership && ownership.entityRevision && ownership.lastSequence) {
+            const payloadFingerprint = fingerprintWorkspaceSyncPayload(task);
+            if (!ownership.canonicalFingerprint) {
+                throw new Error(`Owned task ${taskId} snapshot is missing its durable revision projection.`);
+            }
+            durableRevision = {
+                contractVersion: 3,
+                domain: 'task',
+                entityId: taskId,
+                mutationKind: 'replicated-state',
+                sequence: ownership.lastSequence,
+                entityRevision: ownership.entityRevision,
+                lifecycleRevision: ownership.lifecycleRevision,
+                canonicalFingerprint: ownership.canonicalFingerprint,
+                payloadFingerprint,
+                taxonomyOwned: ownership.taxonomyOwned,
+            };
+        }
         return {
             kind: 'upsert',
             watermark,
             sortId: taskId,
-            task: serializeTaskForSync(entry.task),
-            archived: Boolean(entry.archived)
+            task,
+            archived: Boolean(entry.archived),
+            ...(durableRevision ? { durableRevision } : {}),
         };
     })
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
-    const rawDeleteEntries = core.listWorkspaceSyncDeletesSince(workspaceId, syncCursor, dbFetchLimit);
+    const rawDeleteEntries = excludedProjections.has('task/root-v1')
+        ? [] : core.listWorkspaceSyncDeletesSince(workspaceId, syncCursor, dbFetchLimit);
     const deleteEntries = rawDeleteEntries
         .map((entry) => ({
         kind: 'delete',
         watermark: String(entry.deletedAt || '').trim(),
         sortId: String(entry.taskId || '').trim(),
-        taskId: String(entry.taskId || '').trim()
+        taskId: String(entry.taskId || '').trim(),
+        ...(entry.actor ? { actor: entry.actor } : {}),
+        ...(entry.actorType ? { actorType: entry.actorType } : {}),
+        ...(entry.source ? { source: entry.source } : {}),
+        ...(entry.details ? { details: entry.details } : {}),
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
-    const taxonomySnapshot = readSnapshot('taxonomy', null, () => core.getTaxonomiesSyncSnapshot(workspaceId));
+    const taskRelationshipEntries = (excludedProjections.has('task-relationship/full-v1')
+        ? []
+        : readSnapshot('task-relationships', [], () => core.listTaskRelationshipsForSync(workspaceId, syncCursor, dbFetchLimit)))
+        .map((relationship) => ({
+        kind: 'task-relationship',
+        watermark: relationship.updatedAt,
+        sortId: `task-relationship:${relationship.id}`,
+        relationship,
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.relationship.id.length > 0);
+    const taxonomySnapshot = excludedProjections.has('taxonomy/full-v1')
+        ? null : readSnapshot('taxonomy', null, () => core.getTaxonomiesSyncSnapshot(workspaceId));
     const taxonomyEntries = (taxonomySnapshot
         && Array.isArray(taxonomySnapshot.taxonomies)
         && Number.isFinite(Date.parse(String(taxonomySnapshot.updatedAt || '').trim())))
-        ? [{
-                kind: 'taxonomy',
-                watermark: String(taxonomySnapshot.updatedAt || '').trim(),
-                sortId: '__taxonomy_config__',
-                taxonomies: taxonomySnapshot.taxonomies,
-                ...(taxonomySnapshot.taxonomyState ? { taxonomyState: taxonomySnapshot.taxonomyState } : {})
-            }]
+        ? (() => {
+            if (!durabilityStore)
+                throw new Error('Taxonomy durability projection requires a database adapter.');
+            const ownership = durabilityStore.readWorkspaceDomainOwnership({
+                tenantId: core.getTenantId(),
+                workspaceId,
+                domain: 'taxonomy',
+                entityId: '__taxonomy_config__',
+            });
+            let taxonomyState = taxonomySnapshot.taxonomyState;
+            let durableRevision;
+            if (ownership.owned) {
+                if (!taxonomyState || !ownership.lastSequence || !ownership.canonicalFingerprint) {
+                    throw new Error('Owned taxonomy snapshot is missing its durable revision projection.');
+                }
+                taxonomyState = serializeTaxonomyStateForSync(taxonomyState);
+                const canonicalFingerprint = fingerprintWorkspaceSyncPayload(taxonomyState);
+                if (canonicalFingerprint !== ownership.canonicalFingerprint || ownership.lifecycleRevision !== '0') {
+                    throw new Error('Owned taxonomy snapshot does not match its durable revision fingerprint.');
+                }
+                durableRevision = {
+                    contractVersion: 3,
+                    domain: 'taxonomy',
+                    entityId: '__taxonomy_config__',
+                    mutationKind: 'replace-state',
+                    sequence: ownership.lastSequence,
+                    entityRevision: ownership.entityRevision,
+                    lifecycleRevision: '0',
+                    canonicalFingerprint,
+                };
+            }
+            return [{
+                    kind: 'taxonomy',
+                    watermark: String(taxonomySnapshot.updatedAt || '').trim(),
+                    sortId: '__taxonomy_config__',
+                    taxonomies: taxonomySnapshot.taxonomies,
+                    ...(taxonomyState ? { taxonomyState } : {}),
+                    ...(durableRevision ? { durableRevision } : {}),
+                }];
+        })()
         : [];
-    const initiativeEntries = readSnapshot('initiatives', [], () => core.listInitiatives(workspaceId))
-        .map((initiative) => ({
-        kind: 'initiative',
-        watermark: String(initiative.updatedAt || initiative.createdAt || '').trim(),
-        sortId: `initiative:${String(initiative.id || '').trim()}`,
-        initiative
-    }))
+    const initiativeSnapshot = input.includeInitiatives === false || excludedProjections.has('initiative/full-v1')
+        ? []
+        : readSnapshot('initiatives', [], () => core.listInitiatives(workspaceId));
+    const initiativeProjectionById = new Map();
+    if (durabilityStore) {
+        const initiativeIds = initiativeSnapshot.map((initiative) => String(initiative.id || '').trim()).filter(Boolean).sort();
+        for (let offset = 0; offset < initiativeIds.length; offset += 100) {
+            for (const projection of durabilityStore.listPlanningRevisionProjections({
+                tenantId: core.getTenantId(),
+                workspaceId,
+                domain: 'initiative',
+                entityIds: initiativeIds.slice(offset, offset + 100),
+            }))
+                initiativeProjectionById.set(projection.entityId, projection);
+        }
+    }
+    const initiativeEntries = initiativeSnapshot
+        .map((initiative) => {
+        const initiativeId = String(initiative.id || '').trim();
+        const projection = initiativeProjectionById.get(initiativeId);
+        const ownedProjection = projection?.coexistenceOwned ? projection : undefined;
+        const canonical = ownedProjection
+            ? serializeInitiativeForSync(initiative)
+            : normalizeInitiativeSyncPayload(initiative);
+        if (!canonical) {
+            throw new Error('Initiative is missing canonical sync identity.');
+        }
+        let durableRevision;
+        if (ownedProjection) {
+            if (fingerprintWorkspaceSyncPayload(canonical) !== ownedProjection.canonicalFingerprint) {
+                throw new Error(`Owned initiative ${canonical.id} does not match its durable revision fingerprint.`);
+            }
+            durableRevision = {
+                contractVersion: 3,
+                domain: 'initiative',
+                entityId: canonical.id,
+                mutationKind: ownedProjection.mutationKind,
+                sequence: ownedProjection.lastSequence,
+                entityRevision: ownedProjection.entityRevision,
+                lifecycleRevision: ownedProjection.lifecycleRevision,
+                canonicalFingerprint: ownedProjection.canonicalFingerprint,
+            };
+        }
+        return {
+            kind: 'initiative',
+            watermark: ownedProjection?.occurredAt || String(canonical.updatedAt || canonical.createdAt || '').trim(),
+            sortId: `initiative:${canonical.id}`,
+            initiative: durableRevision ? { ...canonical, durableRevision } : canonical,
+            ...(durableRevision ? { durableRevision } : {}),
+        };
+    })
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.initiative.id.length > 0);
-    const workstreamEntries = readSnapshot('workstreams', [], () => core.listWorkstreams(workspaceId))
-        .map((workstream) => ({
-        kind: 'workstream',
-        watermark: String(workstream.updatedAt || workstream.createdAt || '').trim(),
-        sortId: `workstream:${String(workstream.id || '').trim()}`,
-        workstream
-    }))
-        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.workstream.id.length > 0);
+    const workstreamEntries = excludedProjections.has('workstream/full-v1')
+        ? []
+        : readSnapshot('workstreams', [], () => core.listWorkstreams(workspaceId))
+            .map((workstream) => ({
+            kind: 'workstream',
+            watermark: String(workstream.updatedAt || workstream.createdAt || '').trim(),
+            sortId: `workstream:${String(workstream.id || '').trim()}`,
+            workstream
+        }))
+            .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.workstream.id.length > 0);
     const aiProfileEntries = readSnapshot('ai-profiles', [], () => core.listAiProfiles(workspaceId, { includeArchived: true }))
         .map((profile) => ({
         kind: 'ai-profile',
@@ -89,8 +253,19 @@ export async function buildWorkspacePullFeed(input) {
         profile
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
-    const indexStartedAtMs = Date.now();
-    const documentIndex = await readSnapshotAsync('documents.index', [], () => contentSyncState.listWorkspaceSyncDocumentIndex(core.getPaths().basePath, workspaceId));
+    const contentFrontierStartedAtMs = Date.now();
+    let contentIndexSkipped = false;
+    if (cursor && typeof contentSyncState.hasWorkspaceSyncContentAfter === 'function') {
+        try {
+            contentIndexSkipped = !contentSyncState.hasWorkspaceSyncContentAfter(workspaceId, cursor);
+        }
+        catch (error) {
+            captureSnapshotError('content.frontier', error);
+        }
+    }
+    const contentFrontierMs = Date.now() - contentFrontierStartedAtMs;
+    const documentIndexStartedAtMs = Date.now();
+    const documentIndex = contentIndexSkipped ? [] : await readSnapshotAsync('documents.index', [], () => contentSyncState.listWorkspaceSyncDocumentIndex(core.getPaths().basePath, workspaceId));
     const documentEntries = documentIndex
         .map((doc) => ({
         kind: 'document',
@@ -107,10 +282,14 @@ export async function buildWorkspacePullFeed(input) {
         logicalName: doc.logicalName,
         caption: doc.caption,
         originalFilename: doc.originalFilename,
-        linkRole: (doc.linkRole === 'reference' ? 'reference' : 'attachment')
+        linkRole: (doc.linkRole === 'reference' ? 'reference' : 'attachment'),
+        ...(doc.links ? { links: doc.links } : {}),
+        contentSha256: doc.contentSha256,
+        sizeBytes: doc.sizeBytes,
+        contentAvailable: doc.contentAvailable,
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
-    const documentDeleteEntries = readSnapshot('documents.deletes', [], () => contentSyncState.listWorkspaceSyncDocumentDeletesSnapshot(workspaceId))
+    const documentDeleteEntries = (contentIndexSkipped ? [] : readSnapshot('documents.deletes', [], () => contentSyncState.listWorkspaceSyncDocumentDeletesSnapshot(workspaceId)))
         .map((doc) => ({
         kind: 'document-delete',
         watermark: String(doc.deletedAt || '').trim(),
@@ -119,6 +298,7 @@ export async function buildWorkspacePullFeed(input) {
         assetId: typeof doc.assetId === 'string' && doc.assetId.trim().length > 0 ? doc.assetId.trim() : undefined
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
+    const documentIndexMs = Date.now() - documentIndexStartedAtMs;
     const documentReviewSessions = readSnapshot('document-review-sessions', [], () => collaborationSyncState.listWorkspaceSyncDocumentReviewSessionsSnapshot(workspaceId));
     const documentReviewSessionEntries = documentReviewSessions
         .filter((session) => !session.deletedAt)
@@ -143,8 +323,12 @@ export async function buildWorkspacePullFeed(input) {
         .filter((comment) => !comment.deletedAt)
         .map((comment) => ({
         kind: 'document-review-comment',
-        watermark: String(comment.updatedAt || comment.createdAt || '').trim(),
-        sortId: `document-review-comment:${String(comment.id || '').trim()}`,
+        watermark: [comment.threadStatusUpdatedAt, comment.updatedAt, comment.createdAt]
+            .map((value) => String(value || '').trim())
+            .filter((value) => Number.isFinite(Date.parse(value)))
+            .sort()
+            .at(-1) || '',
+        sortId: `document-review-comment:${comment.parentCommentId ? '1' : '0'}:${String(comment.id || '').trim()}`,
         comment
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.comment.id.length > 0 && entry.comment.sessionId.length > 0);
@@ -154,7 +338,8 @@ export async function buildWorkspacePullFeed(input) {
         kind: 'document-review-comment-delete',
         watermark: String(comment.deletedAt || comment.updatedAt || '').trim(),
         sortId: `document-review-comment-delete:${String(comment.id || '').trim()}`,
-        commentId: String(comment.id || '').trim()
+        commentId: String(comment.id || '').trim(),
+        deletedByActorId: comment.deletedByActorId,
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.commentId.length > 0);
     const annotatedAttachmentSessions = readSnapshot('annotated-attachment-sessions', [], () => collaborationSyncState.listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(workspaceId));
@@ -176,7 +361,42 @@ export async function buildWorkspacePullFeed(input) {
         sessionId: String(session.id || '').trim()
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sessionId.length > 0);
-    const taskEventEntries = readSnapshot('task-events', [], () => collaborationSyncState.listWorkspaceSyncTaskEventsSnapshot(workspaceId))
+    const taskforceAgentEntries = readSnapshot('taskforce-agents', [], () => collaborationSyncState.listWorkspaceSyncTaskforceAgentsSnapshot(workspaceId))
+        .map((agent) => ({
+        kind: 'taskforce-agent',
+        watermark: String(agent.deletedAt || agent.updatedAt || agent.createdAt || '').trim(),
+        sortId: `taskforce-agent:${String(agent.id || '').trim()}`,
+        agent
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.agent.id.length > 0 && entry.agent.workspaceId.length > 0);
+    const agentRoleEntries = readSnapshot('agent-roles', [], () => collaborationSyncState.listWorkspaceSyncAgentRolesSnapshot(workspaceId))
+        .map((role) => ({
+        kind: 'agent-role',
+        watermark: String(role.deletedAt || role.updatedAt || role.createdAt || '').trim(),
+        sortId: `agent-role:${String(role.id || '').trim()}`,
+        role
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.role.id.length > 0 && entry.role.workspaceId.length > 0);
+    const taskforceAgentSkillEntries = readSnapshot('taskforce-agent-skills', [], () => collaborationSyncState.listWorkspaceSyncTaskforceAgentSkillsSnapshot(workspaceId))
+        .map((skill) => ({
+        kind: 'taskforce-agent-skill',
+        watermark: String(skill.updatedAt || skill.createdAt || '').trim(),
+        sortId: `taskforce-agent-skill:${String(skill.id || '').trim()}`,
+        skill
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.skill.id.length > 0 && entry.skill.workspaceId.length > 0);
+    const agentConversationEntries = readSnapshot('agent-conversations', [], () => collaborationSyncState.listWorkspaceSyncAgentConversationsSnapshot(workspaceId))
+        .map((conversation) => ({
+        kind: 'agent-conversation',
+        watermark: String(conversation.deletedAt || conversation.updatedAt || conversation.createdAt || '').trim(),
+        sortId: `agent-conversation:${String(conversation.id || '').trim()}`,
+        conversation
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.conversation.id.length > 0 && entry.conversation.agentId.length > 0);
+    const taskEventEntries = (excludedProjections.has('entity-event/full-v1') ? [] : readSnapshot('task-events', [], () => collaborationSyncState.listWorkspaceSyncTaskEventsSnapshot(workspaceId, {
+        cursor: syncCursor,
+        limit: dbFetchLimit,
+    })))
         .map((event) => {
         const entityType = event.entityType === 'initiative' || event.entityType === 'workstream'
             ? event.entityType
@@ -198,7 +418,7 @@ export async function buildWorkspacePullFeed(input) {
         return {
             kind: 'entity-event',
             watermark: String(event.createdAt || '').trim(),
-            sortId: `entity-event:${String(event.id || '').trim()}`,
+            sortId: `${entityType}:${entityId}:event:${String(event.id || '').trim()}`,
             event: {
                 ...event,
                 entityType,
@@ -207,7 +427,8 @@ export async function buildWorkspacePullFeed(input) {
         };
     })
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.event.id.length > 0 && entry.event.entityId.length > 0 && (entry.kind !== 'task-event' || Boolean(entry.event.taskId)));
-    const assetIndex = await readSnapshotAsync('assets.index', [], () => contentSyncState.listWorkspaceSyncBinaryAssetIndex(workspaceId));
+    const assetIndexStartedAtMs = Date.now();
+    const assetIndex = contentIndexSkipped ? [] : await readSnapshotAsync('assets.index', [], () => contentSyncState.listWorkspaceSyncBinaryAssetIndex(workspaceId));
     const assetEntries = assetIndex
         .map((asset) => ({
         kind: 'asset',
@@ -224,10 +445,14 @@ export async function buildWorkspacePullFeed(input) {
         logicalName: asset.logicalName,
         caption: asset.caption,
         originalFilename: asset.originalFilename,
-        linkRole: asset.linkRole
+        linkRole: asset.linkRole,
+        ...(asset.links ? { links: asset.links } : {}),
+        contentSha256: asset.contentSha256,
+        sizeBytes: asset.sizeBytes,
+        contentAvailable: asset.contentAvailable,
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
-    const assetDeleteEntries = readSnapshot('assets.deletes', [], () => contentSyncState.listWorkspaceSyncBinaryAssetDeletesSnapshot(workspaceId))
+    const assetDeleteEntries = (contentIndexSkipped ? [] : readSnapshot('assets.deletes', [], () => contentSyncState.listWorkspaceSyncBinaryAssetDeletesSnapshot(workspaceId)))
         .map((asset) => ({
         kind: 'asset-delete',
         watermark: String(asset.deletedAt || '').trim(),
@@ -236,9 +461,11 @@ export async function buildWorkspacePullFeed(input) {
         assetId: typeof asset.assetId === 'string' && asset.assetId.trim().length > 0 ? asset.assetId.trim() : undefined
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
+    const assetIndexMs = Date.now() - assetIndexStartedAtMs;
     const all = [
         ...upsertEntries,
         ...deleteEntries,
+        ...taskRelationshipEntries,
         ...taxonomyEntries,
         ...initiativeEntries,
         ...workstreamEntries,
@@ -251,6 +478,10 @@ export async function buildWorkspacePullFeed(input) {
         ...documentReviewCommentDeleteEntries,
         ...annotatedAttachmentSessionEntries,
         ...annotatedAttachmentSessionDeleteEntries,
+        ...taskforceAgentEntries,
+        ...agentRoleEntries,
+        ...taskforceAgentSkillEntries,
+        ...agentConversationEntries,
         ...taskEventEntries,
         ...assetEntries,
         ...assetDeleteEntries
@@ -262,12 +493,14 @@ export async function buildWorkspacePullFeed(input) {
             return true;
         if (entry.watermark < cursor.u)
             return false;
-        return entry.sortId > cursor.id;
+        return compareUtf8CursorText(entry.sortId, cursor.id) > 0;
     });
     afterCursor.sort((a, b) => {
         if (a.watermark !== b.watermark)
-            return a.watermark.localeCompare(b.watermark);
-        return String(a.sortId || '').localeCompare(String(b.sortId || ''));
+            return a.watermark < b.watermark ? -1 : 1;
+        const leftSortId = String(a.sortId || '');
+        const rightSortId = String(b.sortId || '');
+        return compareUtf8CursorText(leftSortId, rightSortId);
     });
     const page = afterCursor.slice(0, pageSize);
     const workspaceMembers = readSnapshot('workspace-members', [], () => core.listWorkspaceUsers(workspaceId)).map((member) => ({
@@ -284,11 +517,13 @@ export async function buildWorkspacePullFeed(input) {
         updatedAt: member.updatedAt || null,
         emailVerifiedAt: member.emailVerifiedAt || null
     }));
-    const indexMs = Date.now() - indexStartedAtMs;
+    const indexMs = documentIndexMs + assetIndexMs;
     const hydratedDocuments = new Map();
     const hydratedAssets = new Map();
     const hydrationStartedAtMs = Date.now();
     await Promise.all(page.map(async (entry) => {
+        if (contentMode === 'manifest')
+            return;
         if (entry.kind === 'document') {
             const payload = await contentSyncState.loadWorkspaceSyncDocumentPayload(core.getPaths().basePath, workspaceId, entry.path);
             hydratedDocuments.set(entry.path, payload);
@@ -300,100 +535,235 @@ export async function buildWorkspacePullFeed(input) {
         }
     }));
     const hydrationMs = Date.now() - hydrationStartedAtMs;
-    const skippedHydrationEntries = page.filter((entry) => ((entry.kind === 'document' && !hydratedDocuments.get(entry.path))
-        || (entry.kind === 'asset' && !hydratedAssets.get(entry.path)))).length;
-    const effectivePage = page;
-    const hasMore = afterCursor.length > page.length;
-    const last = page.length > 0 ? page[page.length - 1] : null;
+    const isHydrationMissing = (entry) => ((entry.kind === 'document' && !hydratedDocuments.get(entry.path))
+        || (entry.kind === 'asset' && !hydratedAssets.get(entry.path)));
+    const isContentUnavailable = (entry) => ((entry.kind === 'document' || entry.kind === 'asset')
+        && entry.contentAvailable === false);
+    const isSkippedContentEntry = (_entry) => false;
+    const encodeStartedAtMs = Date.now();
+    const encodedChanges = page
+        .flatMap((entry) => (entry.kind === 'delete'
+        ? [{
+                op: 'delete',
+                taskId: entry.taskId,
+                deletedAt: entry.watermark,
+                watermark: entry.watermark,
+                ...(entry.actor ? { actor: entry.actor } : {}),
+                ...(entry.actorType ? { actorType: entry.actorType } : {}),
+                ...(entry.source ? { source: entry.source } : {}),
+                ...(entry.details ? { details: entry.details } : {}),
+            }]
+        : entry.kind === 'task-relationship'
+            ? [{ op: entry.relationship.deletedAt ? 'task-relationship-delete' : 'task-relationship-upsert', relationship: entry.relationship, watermark: entry.watermark }]
+            : entry.kind === 'taxonomy'
+                ? [{
+                        op: 'taxonomy-upsert',
+                        taxonomies: entry.taxonomies,
+                        ...(entry.taxonomyState ? { taxonomyState: entry.taxonomyState } : {}),
+                        ...(entry.durableRevision ? { durableRevision: entry.durableRevision } : {}),
+                        updatedAt: entry.watermark,
+                        watermark: entry.watermark
+                    }]
+                : entry.kind === 'initiative'
+                    ? [{ op: 'initiative-upsert', initiative: entry.initiative, watermark: entry.watermark }]
+                    : entry.kind === 'workstream'
+                        ? [{ op: 'workstream-upsert', workstream: entry.workstream, watermark: entry.watermark }]
+                        : entry.kind === 'ai-profile'
+                            ? [{ op: 'ai-profile-upsert', profile: entry.profile, watermark: entry.watermark }]
+                            : entry.kind === 'document-review-session'
+                                ? [{ op: 'document-review-session-upsert', session: entry.session, watermark: entry.watermark }]
+                                : entry.kind === 'document-review-session-delete'
+                                    ? [{ op: 'document-review-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                    : entry.kind === 'document-review-comment'
+                                        ? [{ op: 'document-review-comment-upsert', comment: entry.comment, watermark: entry.watermark }]
+                                        : entry.kind === 'document-review-comment-delete'
+                                            ? [{
+                                                    op: 'document-review-comment-delete',
+                                                    commentId: entry.commentId,
+                                                    deletedAt: entry.watermark,
+                                                    deletedByActorId: entry.deletedByActorId,
+                                                    watermark: entry.watermark,
+                                                }]
+                                            : entry.kind === 'annotated-attachment-session'
+                                                ? [{ op: 'annotated-attachment-session-upsert', session: entry.session, watermark: entry.watermark }]
+                                                : entry.kind === 'annotated-attachment-session-delete'
+                                                    ? [{ op: 'annotated-attachment-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                    : entry.kind === 'taskforce-agent'
+                                                        ? [{ op: 'taskforce-agent-upsert', agent: entry.agent, watermark: entry.watermark }]
+                                                        : entry.kind === 'agent-role'
+                                                            ? [{ op: 'agent-role-upsert', role: entry.role, watermark: entry.watermark }]
+                                                            : entry.kind === 'taskforce-agent-skill'
+                                                                ? [{ op: 'taskforce-agent-skill-upsert', skill: entry.skill, watermark: entry.watermark }]
+                                                                : entry.kind === 'agent-conversation'
+                                                                    ? [{ op: 'agent-conversation-upsert', conversation: entry.conversation, watermark: entry.watermark }]
+                                                                    : entry.kind === 'task-event'
+                                                                        ? [{ op: 'task-event-upsert', event: entry.event, watermark: entry.watermark }]
+                                                                        : entry.kind === 'entity-event'
+                                                                            ? [{ op: 'entity-event-upsert', event: entry.event, watermark: entry.watermark }]
+                                                                            : entry.kind === 'document'
+                                                                                ? (() => {
+                                                                                    if (contentMode === 'manifest'
+                                                                                        || isHydrationMissing(entry)
+                                                                                        || isContentUnavailable(entry)) {
+                                                                                        const metadata = {
+                                                                                            assetId: entry.assetId,
+                                                                                            documentId: entry.documentId,
+                                                                                            referenceNumber: entry.referenceNumber,
+                                                                                            version: entry.version,
+                                                                                            taskId: entry.taskId,
+                                                                                            linkTargetType: entry.linkTargetType,
+                                                                                            linkTargetId: entry.linkTargetId,
+                                                                                            logicalName: entry.logicalName,
+                                                                                            caption: entry.caption,
+                                                                                            originalFilename: entry.originalFilename,
+                                                                                            linkRole: entry.linkRole,
+                                                                                            links: entry.links,
+                                                                                        };
+                                                                                        return [{
+                                                                                                op: 'document-manifest',
+                                                                                                manifest: {
+                                                                                                    manifestVersion: WORKSPACE_CONTENT_MANIFEST_VERSION,
+                                                                                                    kind: 'document',
+                                                                                                    path: entry.path,
+                                                                                                    sha256: entry.contentSha256,
+                                                                                                    sizeBytes: entry.sizeBytes,
+                                                                                                    updatedAt: entry.watermark,
+                                                                                                    metadataFingerprint: createWorkspaceContentMetadataFingerprintV1({
+                                                                                                        kind: 'document',
+                                                                                                        metadata,
+                                                                                                    }),
+                                                                                                    existsLocally: entry.contentAvailable,
+                                                                                                },
+                                                                                                metadata,
+                                                                                                watermark: entry.watermark,
+                                                                                            }];
+                                                                                    }
+                                                                                    const payload = hydratedDocuments.get(entry.path);
+                                                                                    if (!payload)
+                                                                                        return [];
+                                                                                    return [{
+                                                                                            op: 'document-upsert',
+                                                                                            path: entry.path,
+                                                                                            updatedAt: entry.watermark,
+                                                                                            content: payload.content,
+                                                                                            assetId: payload.assetId,
+                                                                                            documentId: payload.documentId,
+                                                                                            referenceNumber: payload.referenceNumber,
+                                                                                            version: payload.version,
+                                                                                            taskId: payload.taskId,
+                                                                                            linkTargetType: payload.linkTargetType,
+                                                                                            linkTargetId: payload.linkTargetId,
+                                                                                            logicalName: payload.logicalName,
+                                                                                            caption: payload.caption,
+                                                                                            originalFilename: payload.originalFilename,
+                                                                                            linkRole: payload.linkRole === 'reference' ? 'reference' : 'attachment',
+                                                                                            ...(payload.links ? { links: payload.links } : {}),
+                                                                                            watermark: entry.watermark
+                                                                                        }];
+                                                                                })()
+                                                                                : entry.kind === 'document-delete'
+                                                                                    ? [{ op: 'document-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                                                    : entry.kind === 'asset'
+                                                                                        ? (() => {
+                                                                                            if (contentMode === 'manifest'
+                                                                                                || isHydrationMissing(entry)
+                                                                                                || isContentUnavailable(entry)) {
+                                                                                                const metadata = {
+                                                                                                    assetId: entry.assetId,
+                                                                                                    assetKind: entry.kindValue,
+                                                                                                    mimeType: entry.mimeType,
+                                                                                                    referenceNumber: entry.referenceNumber,
+                                                                                                    taskId: entry.taskId,
+                                                                                                    linkTargetType: entry.linkTargetType,
+                                                                                                    linkTargetId: entry.linkTargetId,
+                                                                                                    logicalName: entry.logicalName,
+                                                                                                    caption: entry.caption,
+                                                                                                    originalFilename: entry.originalFilename,
+                                                                                                    linkRole: entry.linkRole,
+                                                                                                    links: entry.links,
+                                                                                                };
+                                                                                                return [{
+                                                                                                        op: 'asset-manifest',
+                                                                                                        manifest: {
+                                                                                                            manifestVersion: WORKSPACE_CONTENT_MANIFEST_VERSION,
+                                                                                                            kind: 'asset',
+                                                                                                            path: entry.path,
+                                                                                                            sha256: entry.contentSha256,
+                                                                                                            sizeBytes: entry.sizeBytes,
+                                                                                                            updatedAt: entry.watermark,
+                                                                                                            metadataFingerprint: createWorkspaceContentMetadataFingerprintV1({
+                                                                                                                kind: 'asset',
+                                                                                                                metadata,
+                                                                                                            }),
+                                                                                                            existsLocally: entry.contentAvailable,
+                                                                                                        },
+                                                                                                        metadata,
+                                                                                                        watermark: entry.watermark,
+                                                                                                    }];
+                                                                                            }
+                                                                                            const payload = hydratedAssets.get(entry.path);
+                                                                                            if (!payload)
+                                                                                                return [];
+                                                                                            return [{
+                                                                                                    op: 'asset-upsert',
+                                                                                                    path: entry.path,
+                                                                                                    updatedAt: entry.watermark,
+                                                                                                    contentBase64: payload.contentBase64,
+                                                                                                    assetId: payload.assetId,
+                                                                                                    kind: payload.kind,
+                                                                                                    mimeType: payload.mimeType,
+                                                                                                    referenceNumber: payload.referenceNumber,
+                                                                                                    taskId: payload.taskId,
+                                                                                                    linkTargetType: payload.linkTargetType,
+                                                                                                    linkTargetId: payload.linkTargetId,
+                                                                                                    logicalName: payload.logicalName,
+                                                                                                    caption: payload.caption,
+                                                                                                    originalFilename: payload.originalFilename,
+                                                                                                    linkRole: payload.linkRole,
+                                                                                                    ...(payload.links ? { links: payload.links } : {}),
+                                                                                                    watermark: entry.watermark
+                                                                                                }];
+                                                                                        })()
+                                                                                        : entry.kind === 'asset-delete'
+                                                                                            ? [{ op: 'asset-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                                                            : [{
+                                                                                                    op: 'upsert',
+                                                                                                    task: entry.task,
+                                                                                                    archived: Boolean(entry.archived),
+                                                                                                    ...(entry.durableRevision ? { durableRevision: entry.durableRevision } : {}),
+                                                                                                    watermark: entry.watermark,
+                                                                                                }]));
+    let pageBytes = Buffer.byteLength(JSON.stringify({ workspaceId, changes: [], workspaceMembers }), 'utf8');
+    let includedEntryCount = 0;
+    let includedChangeCount = 0;
+    let encodedChangeIndex = 0;
+    for (const entry of page) {
+        if (isSkippedContentEntry(entry)) {
+            includedEntryCount += 1;
+            continue;
+        }
+        const change = encodedChanges[encodedChangeIndex];
+        encodedChangeIndex += 1;
+        const changeBytes = Buffer.byteLength(JSON.stringify(change), 'utf8') + (includedChangeCount > 0 ? 1 : 0);
+        if (includedChangeCount === 0 && pageBytes + changeBytes > maxPageBytes) {
+            throw new WorkspacePullEntryTooLargeError(entry, pageBytes + changeBytes, maxPageBytes);
+        }
+        if (includedChangeCount > 0 && pageBytes + changeBytes > maxPageBytes) {
+            break;
+        }
+        pageBytes += changeBytes;
+        includedEntryCount += 1;
+        includedChangeCount += 1;
+    }
+    const effectivePage = page.slice(0, includedEntryCount);
+    const changes = encodedChanges.slice(0, includedChangeCount);
+    const skippedHydrationEntries = effectivePage.filter(isSkippedContentEntry).length;
+    const byteLimited = effectivePage.length < page.length;
+    const hasMore = afterCursor.length > effectivePage.length;
+    const last = effectivePage.length > 0 ? effectivePage[effectivePage.length - 1] : null;
     const nextCursor = encodeWorkspaceSyncCursor(last
         ? { u: last.watermark, id: String(last.sortId || '') }
         : cursor);
-    const encodeStartedAtMs = Date.now();
-    const changes = effectivePage.flatMap((entry) => (entry.kind === 'delete'
-        ? [{ op: 'delete', taskId: entry.taskId, watermark: entry.watermark }]
-        : entry.kind === 'taxonomy'
-            ? [{
-                    op: 'taxonomy-upsert',
-                    taxonomies: entry.taxonomies,
-                    ...(entry.taxonomyState ? { taxonomyState: entry.taxonomyState } : {}),
-                    updatedAt: entry.watermark,
-                    watermark: entry.watermark
-                }]
-            : entry.kind === 'initiative'
-                ? [{ op: 'initiative-upsert', initiative: entry.initiative, watermark: entry.watermark }]
-                : entry.kind === 'workstream'
-                    ? [{ op: 'workstream-upsert', workstream: entry.workstream, watermark: entry.watermark }]
-                    : entry.kind === 'ai-profile'
-                        ? [{ op: 'ai-profile-upsert', profile: entry.profile, watermark: entry.watermark }]
-                        : entry.kind === 'document-review-session'
-                            ? [{ op: 'document-review-session-upsert', session: entry.session, watermark: entry.watermark }]
-                            : entry.kind === 'document-review-session-delete'
-                                ? [{ op: 'document-review-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
-                                : entry.kind === 'document-review-comment'
-                                    ? [{ op: 'document-review-comment-upsert', comment: entry.comment, watermark: entry.watermark }]
-                                    : entry.kind === 'document-review-comment-delete'
-                                        ? [{ op: 'document-review-comment-delete', commentId: entry.commentId, deletedAt: entry.watermark, watermark: entry.watermark }]
-                                        : entry.kind === 'annotated-attachment-session'
-                                            ? [{ op: 'annotated-attachment-session-upsert', session: entry.session, watermark: entry.watermark }]
-                                            : entry.kind === 'annotated-attachment-session-delete'
-                                                ? [{ op: 'annotated-attachment-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
-                                                : entry.kind === 'task-event'
-                                                    ? [{ op: 'task-event-upsert', event: entry.event, watermark: entry.watermark }]
-                                                    : entry.kind === 'entity-event'
-                                                        ? [{ op: 'entity-event-upsert', event: entry.event, watermark: entry.watermark }]
-                                                        : entry.kind === 'document'
-                                                            ? (() => {
-                                                                const payload = hydratedDocuments.get(entry.path);
-                                                                if (!payload)
-                                                                    return [];
-                                                                return [{
-                                                                        op: 'document-upsert',
-                                                                        path: entry.path,
-                                                                        updatedAt: entry.watermark,
-                                                                        content: payload.content,
-                                                                        assetId: payload.assetId,
-                                                                        documentId: payload.documentId,
-                                                                        referenceNumber: payload.referenceNumber,
-                                                                        version: payload.version,
-                                                                        taskId: payload.taskId,
-                                                                        linkTargetType: payload.linkTargetType,
-                                                                        linkTargetId: payload.linkTargetId,
-                                                                        logicalName: payload.logicalName,
-                                                                        caption: payload.caption,
-                                                                        originalFilename: payload.originalFilename,
-                                                                        linkRole: payload.linkRole === 'reference' ? 'reference' : 'attachment',
-                                                                        watermark: entry.watermark
-                                                                    }];
-                                                            })()
-                                                            : entry.kind === 'document-delete'
-                                                                ? [{ op: 'document-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
-                                                                : entry.kind === 'asset'
-                                                                    ? (() => {
-                                                                        const payload = hydratedAssets.get(entry.path);
-                                                                        if (!payload)
-                                                                            return [];
-                                                                        return [{
-                                                                                op: 'asset-upsert',
-                                                                                path: entry.path,
-                                                                                updatedAt: entry.watermark,
-                                                                                contentBase64: payload.contentBase64,
-                                                                                assetId: payload.assetId,
-                                                                                kind: payload.kind,
-                                                                                mimeType: payload.mimeType,
-                                                                                referenceNumber: payload.referenceNumber,
-                                                                                taskId: payload.taskId,
-                                                                                linkTargetType: payload.linkTargetType,
-                                                                                linkTargetId: payload.linkTargetId,
-                                                                                logicalName: payload.logicalName,
-                                                                                caption: payload.caption,
-                                                                                originalFilename: payload.originalFilename,
-                                                                                linkRole: payload.linkRole,
-                                                                                watermark: entry.watermark
-                                                                            }];
-                                                                    })()
-                                                                    : entry.kind === 'asset-delete'
-                                                                        ? [{ op: 'asset-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
-                                                                        : [{ op: 'upsert', task: entry.task, archived: Boolean(entry.archived), watermark: entry.watermark }]));
     const encodeMs = Date.now() - encodeStartedAtMs;
     return {
         workspaceMembers,
@@ -402,10 +772,17 @@ export async function buildWorkspacePullFeed(input) {
         hasMore,
         diagnostics: {
             totalEntries: all.length,
-            pageEntries: page.length,
+            pageEntries: effectivePage.length,
+            pageBytes,
+            pageByteLimit: maxPageBytes,
+            byteLimited,
             skippedHydrationEntries,
             documentIndexCount: documentIndex.length,
             assetIndexCount: assetIndex.length,
+            contentFrontierMs,
+            contentIndexSkipped,
+            documentIndexMs,
+            assetIndexMs,
             indexMs,
             hydrationMs,
             encodeMs,