@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/syncService.js

@@ -1,8 +1,28 @@
-import { applyLocalWorkspaceChanges, handshakeWorkspace, pullWorkspaceChanges, provisionWorkspace, pullUserSettings, pushUserSettings, pushWorkspaceChanges } from './cloudSyncApi';
-import { encryptDocument, decryptDocument } from './encryptionService';
+import { applyLocalWorkspaceChanges, getLocalWorkspaceContentPullObligations, recordLocalWorkspaceContentPullObligationFailures, getLocalWorkspaceContentManifest, pullUserSettings, pushUserSettings, prepareWorkspacePushChanges, } from './cloudSyncApi.js';
+import { workspaceSyncContentPullObligationId, } from './engine/workspaceSyncContentPullObligationStore.js';
+import { createBrowserWorkspaceSyncEngineRemoteServices, } from './engine/workspaceSyncEngineRemoteServices.js';
+import { createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEngineAppliedTaskUpserts, workspaceSyncEngineExpectedTaskEchoIds, } from './engine/workspaceSyncEnginePushCompletion.js';
+import { encryptDocument } from './encryptionService.js';
+import { decryptWorkspaceSyncContentChangeInPlace } from './workspaceSyncContentDecryption.js';
+import { decideWorkspaceContentFetch, fingerprintWorkspaceContentBody, } from './workspaceContentManifest.js';
+import { workspaceSyncV2ProjectionExclusionsEqual, } from './v3/workspaceSyncV2ProjectionExclusions.js';
+import { WORKSPACE_PUSH_PREPARED_PLAN_VERSION, } from './workspacePushPreparedPlan.js';
+import { canonicalWorkspaceSyncJson } from './v3/canonicalWorkspaceSyncJson.js';
 function asObjectRecord(value) {
     return value && typeof value === 'object' ? value : {};
 }
+const CONTENT_PULL_RETRY_BASE_MS = 30_000;
+const CONTENT_PULL_RETRY_MAX_MS = 60 * 60_000;
+function isContentPullObligationDue(obligation, nowMs = Date.now()) {
+    const attempts = Math.max(0, Math.floor(Number(obligation.attempts) || 0));
+    if (attempts === 0)
+        return true;
+    const updatedAtMs = Date.parse(String(obligation.updatedAt || ''));
+    if (!Number.isFinite(updatedAtMs))
+        return true;
+    const delayMs = Math.min(CONTENT_PULL_RETRY_MAX_MS, CONTENT_PULL_RETRY_BASE_MS * (2 ** Math.min(attempts - 1, 7)));
+    return updatedAtMs + delayMs <= nowMs;
+}
 export function isTransientWorkspaceSyncStatus(status) {
     const normalized = Number(status || 0);
     return normalized === 0 || normalized === 429 || normalized >= 500;
@@ -31,7 +51,9 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
     if (!input.isAuthenticated)
         return { success: false, error: 'Authentication required.' };
     try {
-        let handshakeResult = await handshakeWorkspace(input.resolveCloudAuthUrl, input.workspaceId);
+        const remoteServices = input.remoteServices
+            || createBrowserWorkspaceSyncEngineRemoteServices(input.resolveCloudAuthUrl);
+        let handshakeResult = await remoteServices.handshakeWorkspace(input.workspaceId);
         if (handshakeResult.ok)
             return { success: true, provisioned: false };
         const data = asObjectRecord(handshakeResult.data);
@@ -53,7 +75,7 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
             };
         }
         if (isMissingCloudWorkspaceSelection(data, handshakeResult.status)) {
-            const provisionResult = await provisionWorkspace(input.resolveCloudAuthUrl, {
+            const provisionResult = await remoteServices.provisionWorkspace({
                 workspaceId: input.workspaceId,
                 name: input.workspaceName || input.workspaceId
             });
@@ -67,7 +89,7 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
                     error: resolveWorkspaceAccessConflictMessage(provisionError, provisionResult.status)
                 };
             }
-            handshakeResult = await handshakeWorkspace(input.resolveCloudAuthUrl, input.workspaceId);
+            handshakeResult = await remoteServices.handshakeWorkspace(input.workspaceId);
             if (!handshakeResult.ok) {
                 const retryData = asObjectRecord(handshakeResult.data);
                 if (handshakeResult.status === 401) {
@@ -94,7 +116,7 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
                     error: String(data.error || 'Selected cloud workspace could not be attached to this local workspace.')
                 };
             }
-            const provisionResult = await provisionWorkspace(input.resolveCloudAuthUrl, {
+            const provisionResult = await remoteServices.provisionWorkspace({
                 workspaceId: input.workspaceId,
                 name: input.workspaceName || input.workspaceId
             });
@@ -106,7 +128,7 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
                     error: resolveWorkspaceAccessConflictMessage(provisionError, provisionResult.status)
                 };
             }
-            handshakeResult = await handshakeWorkspace(input.resolveCloudAuthUrl, input.workspaceId);
+            handshakeResult = await remoteServices.handshakeWorkspace(input.workspaceId);
             if (!handshakeResult.ok) {
                 const retryData = asObjectRecord(handshakeResult.data);
                 if (handshakeResult.status === 401) {
@@ -135,8 +157,37 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
         return { success: false, statusCode: 0, transient: true, error: 'Failed to validate workspace sync access.' };
     }
 }
-async function computeIdempotencyKey(workspaceId, changes) {
-    const text = JSON.stringify([workspaceId, changes]);
+function buildEffectiveWorkspacePushDiagnostics(diagnostics, changes, ownership) {
+    if (!diagnostics)
+        return undefined;
+    const byOp = {};
+    for (const change of changes)
+        byOp[change.op] = (byOp[change.op] || 0) + 1;
+    const withChangeCount = (domain, changeCount) => domain ? { ...domain, changeCount } : domain;
+    return {
+        ...diagnostics,
+        totalChanges: changes.length,
+        byOp,
+        domains: {
+            ...diagnostics.domains,
+            tasks: withChangeCount(diagnostics.domains.tasks, (byOp.upsert || 0) + (byOp.delete || 0)),
+            taskRelationships: withChangeCount(diagnostics.domains.taskRelationships, (byOp['task-relationship-upsert'] || 0) + (byOp['task-relationship-delete'] || 0)),
+            initiatives: withChangeCount(diagnostics.domains.initiatives, byOp['initiative-upsert'] || 0),
+            workstreams: withChangeCount(diagnostics.domains.workstreams, byOp['workstream-upsert'] || 0),
+            taxonomy: withChangeCount(diagnostics.domains.taxonomy, byOp['taxonomy-upsert'] || 0),
+        },
+        ...(ownership?.combinedV3SuppressedChangeCount
+            ? { combinedV3SuppressedChangeCount: ownership.combinedV3SuppressedChangeCount }
+            : {}),
+    };
+}
+async function computeIdempotencyKey(workspaceId, changes, repairMode) {
+    const text = canonicalWorkspaceSyncJson({
+        contractVersion: 1,
+        workspaceId,
+        repairMode,
+        changes
+    });
     try {
         const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
         return Array.from(new Uint8Array(buffer)).map(b => b.toString(16).padStart(2, '0')).join('');
@@ -144,7 +195,7 @@ async function computeIdempotencyKey(workspaceId, changes) {
     catch {
         // Deterministic fallback for environments lacking crypto.subtle.
         // Uses FNV-1a over the serialized payload so retries with identical
-        // workspace+changes reuse the same idempotency key.
+        // server-semantic request reuse the same idempotency key.
         let hash = 0x811c9dc5;
         for (let i = 0; i < text.length; i += 1) {
             hash ^= text.charCodeAt(i);
@@ -154,13 +205,323 @@ async function computeIdempotencyKey(workspaceId, changes) {
         return `${workspaceId}:fallback:${hex}`;
     }
 }
+const MAX_WORKSPACE_PUSH_CHANGES_PER_REQUEST = 64;
+const MAX_WORKSPACE_PUSH_BYTES_PER_REQUEST = 4 * 1024 * 1024;
+const MAX_WORKSPACE_PUSH_SINGLE_CHANGE_BYTES = 45 * 1024 * 1024;
+const WORKSPACE_PUSH_REQUEST_OVERHEAD_BYTES = 64 * 1024;
+function workspacePushChangeStableIdentity(change) {
+    switch (change.op) {
+        case 'upsert': return `${change.op}:${change.task.id}`;
+        case 'delete': return `${change.op}:${change.taskId}`;
+        case 'task-relationship-upsert':
+        case 'task-relationship-delete': return `${change.op}:${change.relationship.id}`;
+        case 'initiative-upsert': return `${change.op}:${change.initiative.id}`;
+        case 'workstream-upsert': return `${change.op}:${change.workstream.id}`;
+        case 'planning-identity-upsert': return `${change.op}:${change.identity.entityType}:${change.identity.entityId}`;
+        case 'taxonomy-upsert': return change.op;
+        case 'ai-profile-upsert': return `${change.op}:${change.profile.id}`;
+        case 'document-upsert':
+        case 'document-delete': return `${change.op}:${change.path}`;
+        case 'document-manifest': return `${change.op}:${change.manifest.path}`;
+        case 'asset-upsert':
+        case 'asset-delete': return `${change.op}:${change.path}`;
+        case 'asset-manifest': return `${change.op}:${change.manifest.path}`;
+        case 'document-review-session-upsert': return `${change.op}:${change.session.id}`;
+        case 'document-review-session-delete': return `${change.op}:${change.sessionId}`;
+        case 'document-review-comment-upsert': return `${change.op}:${change.comment.id}`;
+        case 'document-review-comment-delete': return `${change.op}:${change.commentId}`;
+        case 'annotated-attachment-session-upsert': return `${change.op}:${change.session.id}`;
+        case 'annotated-attachment-session-delete': return `${change.op}:${change.sessionId}`;
+        case 'taskforce-agent-upsert': return `${change.op}:${change.agent.id}`;
+        case 'agent-role-upsert': return `${change.op}:${change.role.id}`;
+        case 'taskforce-agent-skill-upsert': return `${change.op}:${change.skill.id}`;
+        case 'agent-conversation-upsert': return `${change.op}:${change.conversation.id}`;
+        case 'entity-event-upsert': return `${change.op}:${change.event.id}`;
+        case 'task-event-upsert': return `${change.op}:${change.event.id}`;
+    }
+}
+function buildPreparedPlanEntries(sourceChanges, preparedChanges) {
+    const sourceIndexesByIdentity = new Map();
+    for (const [index, change] of sourceChanges.entries()) {
+        const identity = workspacePushChangeStableIdentity(change);
+        const indexes = sourceIndexesByIdentity.get(identity) || [];
+        indexes.push(index);
+        sourceIndexesByIdentity.set(identity, indexes);
+    }
+    const consumedByIdentity = new Map();
+    return preparedChanges.map((change) => {
+        const identity = workspacePushChangeStableIdentity(change);
+        const indexes = sourceIndexesByIdentity.get(identity) || [];
+        const offset = consumedByIdentity.get(identity) || 0;
+        const sourceChangeIndex = indexes[offset];
+        if (sourceChangeIndex === undefined) {
+            throw new Error(`Prepared V2 push change is not present in the frozen payload: ${identity}.`);
+        }
+        consumedByIdentity.set(identity, offset + 1);
+        const sourceChange = sourceChanges[sourceChangeIndex];
+        return JSON.stringify(sourceChange) === JSON.stringify(change)
+            ? { sourceChangeIndex }
+            : { sourceChangeIndex, preparedChange: change };
+    });
+}
+function reconstructPreparedPlanBatches(sourceChanges, plan) {
+    const seenIndexes = new Set();
+    return plan.batches.map((batch) => batch.map((entry) => {
+        const index = entry.sourceChangeIndex;
+        if (!Number.isSafeInteger(index) || index < 0 || index >= sourceChanges.length || seenIndexes.has(index)) {
+            throw new Error('Persisted V2 push prepared plan contains an invalid source change index.');
+        }
+        seenIndexes.add(index);
+        return entry.preparedChange || sourceChanges[index];
+    }));
+}
+function resolveWorkspacePushPhase(change) {
+    switch (change.op) {
+        case 'taxonomy-upsert':
+        case 'ai-profile-upsert':
+        case 'initiative-upsert':
+        case 'taskforce-agent-upsert':
+        case 'taskforce-agent-skill-upsert':
+            return 0;
+        case 'workstream-upsert':
+            return 1;
+        case 'planning-identity-upsert':
+            return 2;
+        case 'upsert':
+            return 2;
+        case 'document-upsert':
+        case 'document-manifest':
+        case 'asset-upsert':
+        case 'asset-manifest':
+            return 3;
+        case 'document-review-session-upsert':
+        case 'annotated-attachment-session-upsert':
+        case 'agent-conversation-upsert':
+        case 'task-relationship-upsert':
+            return 4;
+        case 'document-review-comment-upsert':
+        case 'task-event-upsert':
+        case 'entity-event-upsert':
+            return 5;
+        case 'document-review-comment-delete':
+        case 'annotated-attachment-session-delete':
+        case 'task-relationship-delete':
+            return 6;
+        case 'document-review-session-delete':
+        case 'document-delete':
+        case 'asset-delete':
+            return 7;
+        case 'delete':
+            return 8;
+        default:
+            return 4;
+    }
+}
+function isWorkspacePushContentChange(change) {
+    return change.op === 'document-upsert'
+        || change.op === 'document-manifest'
+        || change.op === 'asset-upsert'
+        || change.op === 'asset-manifest'
+        || change.op === 'document-delete'
+        || change.op === 'asset-delete';
+}
+function measureWorkspacePushBatchBytes(input, safeChanges) {
+    return WORKSPACE_PUSH_REQUEST_OVERHEAD_BYTES + new TextEncoder().encode(JSON.stringify({
+        workspaceId: input.workspaceId,
+        idempotencyKey: '0'.repeat(64),
+        changes: safeChanges,
+        repairMode: input.repairMode === true,
+        repair: input.repairMode === true
+    })).byteLength;
+}
+function chunkWorkspacePushChanges(input, plainChanges, safeChanges) {
+    const pairs = plainChanges
+        .map((plain, index) => ({
+        plain,
+        safe: safeChanges[index],
+        phase: resolveWorkspacePushPhase(plain),
+        preparedIndex: index,
+    }))
+        .sort((left, right) => left.phase - right.phase || left.preparedIndex - right.preparedIndex);
+    if (pairs.length === 0)
+        return { batches: [[]], oversizedChangeIndex: null };
+    const batches = [];
+    let batch = [];
+    for (const pair of pairs) {
+        const singleBytes = measureWorkspacePushBatchBytes(input, [pair.safe]);
+        if (singleBytes > MAX_WORKSPACE_PUSH_SINGLE_CHANGE_BYTES) {
+            return { batches: [], oversizedChangeIndex: pair.preparedIndex };
+        }
+        const phaseChanged = batch.length > 0 && batch[0].phase !== pair.phase;
+        const candidate = [...batch, pair];
+        const candidateTooLarge = batch.length > 0
+            && measureWorkspacePushBatchBytes(input, candidate.map((entry) => entry.safe)) > MAX_WORKSPACE_PUSH_BYTES_PER_REQUEST;
+        if (phaseChanged || batch.length >= MAX_WORKSPACE_PUSH_CHANGES_PER_REQUEST || candidateTooLarge) {
+            batches.push(batch);
+            batch = [];
+        }
+        batch.push(pair);
+        if (singleBytes > MAX_WORKSPACE_PUSH_BYTES_PER_REQUEST) {
+            batches.push(batch);
+            batch = [];
+        }
+    }
+    if (batch.length > 0)
+        batches.push(batch);
+    return { batches, oversizedChangeIndex: null };
+}
 export async function runWorkspacePushSyncService(input) {
-    const changeCount = input.payload.changes.length;
+    const remoteServices = input.remoteServices
+        || createBrowserWorkspaceSyncEngineRemoteServices(input.resolveCloudAuthUrl);
+    let preparedOwnership = {
+        activeV3TaskMetadataIds: [],
+        activeV3TaskLifecycleIds: [],
+        activeV3TaskReopenAssigneeIds: [],
+        activeV3InitiativeIds: [],
+        initiativeProjectionOwner: 'v2',
+        combinedProjectionOwner: 'v2',
+        combinedProjectionEpoch: '0',
+        combinedV3SuppressedChangeCount: 0,
+    };
+    let preparedChanges;
+    let retainedPreparedPlan = input.preparedPlan || null;
+    let retainedPlanBatches = null;
+    if (retainedPreparedPlan) {
+        if (retainedPreparedPlan.contractVersion !== WORKSPACE_PUSH_PREPARED_PLAN_VERSION) {
+            throw new Error('Persisted V2 push prepared plan version is unsupported.');
+        }
+        retainedPlanBatches = reconstructPreparedPlanBatches(input.payload.changes, retainedPreparedPlan);
+        preparedChanges = retainedPlanBatches.flat();
+        preparedOwnership = retainedPreparedPlan.ownership;
+    }
+    else {
+        preparedChanges = input.payload.changes;
+    }
+    if (!retainedPreparedPlan && preparedChanges.length > 0) {
+        const preparation = await prepareWorkspacePushChanges({
+            workspaceId: input.workspaceId,
+            changes: preparedChanges,
+        }, {
+            readOwnership: input.localServices?.readPushOwnership,
+        });
+        if (!preparation.ok) {
+            const data = asObjectRecord(preparation.data);
+            return {
+                success: false,
+                status: preparation.status,
+                error: typeof data.error === 'string'
+                    ? data.error
+                    : 'Local workspace sync ownership could not be verified.',
+                code: typeof data.code === 'string' ? data.code : undefined,
+                retryAfterMs: preparation.retryAfterMs,
+                transient: isTransientWorkspaceSyncStatus(preparation.status),
+                requestMs: 0,
+                changeCount: input.payload.changes.length,
+                deleteCount: input.payload.deleteTaskIds.size,
+                currentTaskIds: input.payload.currentTaskIds,
+                currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
+                currentTaskChangeKeys: input.payload.currentTaskChangeKeys ?? new Map(),
+                currentTaskRelationshipChangeKeys: input.payload.currentTaskRelationshipChangeKeys ?? new Map(),
+                currentTaxonomyChangeKey: input.payload.currentTaxonomyChangeKey ?? '',
+                deleteTaskIds: input.payload.deleteTaskIds,
+                currentInitiativeIds: input.payload.currentInitiativeIds,
+                currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
+                currentWorkstreamIds: input.payload.currentWorkstreamIds,
+                currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+                currentAiProfileIds: input.payload.currentAiProfileIds,
+                currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
+                currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
+                currentDocumentPaths: input.payload.currentDocumentPaths,
+                deleteDocumentPaths: input.payload.deleteDocumentPaths,
+                currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
+                currentAssetPaths: input.payload.currentAssetPaths,
+                deleteAssetPaths: input.payload.deleteAssetPaths,
+                currentAssetWatermarks: input.payload.currentAssetWatermarks,
+                currentDocumentReviewSessionIds: input.payload.currentDocumentReviewSessionIds,
+                deleteDocumentReviewSessionIds: input.payload.deleteDocumentReviewSessionIds,
+                currentDocumentReviewSessionWatermarks: input.payload.currentDocumentReviewSessionWatermarks,
+                currentDocumentReviewCommentIds: input.payload.currentDocumentReviewCommentIds,
+                deleteDocumentReviewCommentIds: input.payload.deleteDocumentReviewCommentIds,
+                currentDocumentReviewCommentWatermarks: input.payload.currentDocumentReviewCommentWatermarks,
+                currentAnnotatedAttachmentSessionIds: input.payload.currentAnnotatedAttachmentSessionIds,
+                deleteAnnotatedAttachmentSessionIds: input.payload.deleteAnnotatedAttachmentSessionIds,
+                currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
+                currentTaskforceAgentIds: input.payload.currentTaskforceAgentIds ?? new Set(),
+                currentTaskforceAgentWatermarks: input.payload.currentTaskforceAgentWatermarks ?? new Map(),
+                currentTaskforceAgentSkillIds: input.payload.currentTaskforceAgentSkillIds ?? new Set(),
+                currentTaskforceAgentSkillWatermarks: input.payload.currentTaskforceAgentSkillWatermarks ?? new Map(),
+                currentAgentConversationIds: input.payload.currentAgentConversationIds ?? new Set(),
+                currentAgentConversationWatermarks: input.payload.currentAgentConversationWatermarks ?? new Map(),
+                currentTaskEventWatermarks: input.payload.currentTaskEventWatermarks,
+                pushedWatermarks: new Map(),
+                pushedTaskChangeKeys: new Map(),
+                emittedEventIds: [],
+                appliedTaskUpserts: [],
+            };
+        }
+        preparedChanges = preparation.data.changes;
+        preparedOwnership = preparation.data.ownership;
+    }
+    const changeCount = preparedChanges.length;
+    const effectiveDeltaDiagnostics = buildEffectiveWorkspacePushDiagnostics(input.payload.deltaDiagnostics, preparedChanges, preparedOwnership);
     const deleteCount = input.payload.deleteTaskIds.size;
-    const idempotencyKey = await computeIdempotencyKey(input.workspaceId, input.payload.changes);
     let requestMs = 0;
+    const canElideSteadyStateRequest = changeCount === 0
+        && input.repairMode !== true
+        && (preparedOwnership?.combinedProjectionOwner === 'v3'
+            || (Boolean(input.payload.deltaDiagnostics)
+                && input.payload.deltaDiagnostics?.baselineResetReason !== 'missing-baseline'));
+    if (canElideSteadyStateRequest) {
+        return {
+            success: true,
+            syncedAt: new Date().toISOString(),
+            requestMs: 0,
+            changeCount: 0,
+            effectiveDeltaDiagnostics,
+            deleteCount,
+            currentTaskIds: input.payload.currentTaskIds,
+            currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
+            currentTaskChangeKeys: input.payload.currentTaskChangeKeys ?? new Map(),
+            currentTaskRelationshipChangeKeys: input.payload.currentTaskRelationshipChangeKeys ?? new Map(),
+            currentTaxonomyChangeKey: input.payload.currentTaxonomyChangeKey ?? '',
+            deleteTaskIds: input.payload.deleteTaskIds,
+            currentInitiativeIds: input.payload.currentInitiativeIds,
+            currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
+            currentWorkstreamIds: input.payload.currentWorkstreamIds,
+            currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+            currentAiProfileIds: input.payload.currentAiProfileIds,
+            currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
+            currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
+            currentDocumentPaths: input.payload.currentDocumentPaths,
+            deleteDocumentPaths: input.payload.deleteDocumentPaths,
+            currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
+            currentAssetPaths: input.payload.currentAssetPaths,
+            deleteAssetPaths: input.payload.deleteAssetPaths,
+            currentAssetWatermarks: input.payload.currentAssetWatermarks,
+            currentDocumentReviewSessionIds: input.payload.currentDocumentReviewSessionIds,
+            deleteDocumentReviewSessionIds: input.payload.deleteDocumentReviewSessionIds,
+            currentDocumentReviewSessionWatermarks: input.payload.currentDocumentReviewSessionWatermarks,
+            currentDocumentReviewCommentIds: input.payload.currentDocumentReviewCommentIds,
+            deleteDocumentReviewCommentIds: input.payload.deleteDocumentReviewCommentIds,
+            currentDocumentReviewCommentWatermarks: input.payload.currentDocumentReviewCommentWatermarks,
+            currentAnnotatedAttachmentSessionIds: input.payload.currentAnnotatedAttachmentSessionIds,
+            deleteAnnotatedAttachmentSessionIds: input.payload.deleteAnnotatedAttachmentSessionIds,
+            currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
+            currentTaskforceAgentIds: input.payload.currentTaskforceAgentIds ?? new Set(),
+            currentTaskforceAgentWatermarks: input.payload.currentTaskforceAgentWatermarks ?? new Map(),
+            currentTaskforceAgentSkillIds: input.payload.currentTaskforceAgentSkillIds ?? new Set(),
+            currentTaskforceAgentSkillWatermarks: input.payload.currentTaskforceAgentSkillWatermarks ?? new Map(),
+            currentAgentConversationIds: input.payload.currentAgentConversationIds ?? new Set(),
+            currentAgentConversationWatermarks: input.payload.currentAgentConversationWatermarks ?? new Map(),
+            currentTaskEventWatermarks: input.payload.currentTaskEventWatermarks,
+            pushedWatermarks: new Map(),
+            pushedTaskChangeKeys: new Map(),
+            emittedEventIds: [],
+            appliedTaskUpserts: []
+        };
+    }
     // Attempt document encryption if key configured
-    let safeChanges = input.payload.changes;
+    let safeChanges = preparedChanges;
     if (typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
         const syncKey = process.env.TASKFORCE_SYNC_KEY;
         const encryptedChanges = [];
@@ -183,39 +544,38 @@ export async function runWorkspacePushSyncService(input) {
         }
         safeChanges = encryptedChanges;
     }
-    const sendPush = async () => {
-        const requestStartedAtMs = Date.now();
-        const result = await pushWorkspaceChanges(input.resolveCloudAuthUrl, {
-            workspaceId: input.workspaceId,
-            idempotencyKey,
-            changes: safeChanges,
-            repairMode: input.repairMode === true
-        });
-        requestMs += (Date.now() - requestStartedAtMs);
-        return result;
-    };
-    let pushResult = await sendPush();
-    if (!pushResult.ok && (pushResult.status === 403 || pushResult.status === 409)) {
-        const ensured = await input.ensureCloudWorkspaceReadyForSync();
-        if (ensured.success) {
-            pushResult = await sendPush();
-        }
+    let batchPlan = chunkWorkspacePushChanges(input, preparedChanges, safeChanges);
+    if (retainedPlanBatches) {
+        let safeIndex = 0;
+        batchPlan = {
+            oversizedChangeIndex: null,
+            batches: retainedPlanBatches.map((batch) => batch.map((plain) => {
+                const pair = {
+                    plain,
+                    safe: safeChanges[safeIndex],
+                    phase: resolveWorkspacePushPhase(plain),
+                    preparedIndex: safeIndex,
+                };
+                safeIndex += 1;
+                return pair;
+            })),
+        };
     }
-    if (!pushResult.ok) {
-        const data = asObjectRecord(pushResult.data);
+    if (batchPlan.oversizedChangeIndex !== null) {
+        const oversizedChange = preparedChanges[batchPlan.oversizedChangeIndex];
         return {
             success: false,
-            status: pushResult.status,
-            error: typeof data.error === 'string' ? data.error : undefined,
-            code: typeof data.code === 'string' ? data.code : undefined,
-            retryAfterMs: pushResult.retryAfterMs,
-            transient: isTransientWorkspaceSyncStatus(pushResult.status),
+            status: 413,
+            error: `Workspace sync change ${batchPlan.oversizedChangeIndex + 1} (${oversizedChange.op}) exceeds the single-change transfer limit.`,
+            transient: false,
             requestMs,
             changeCount,
             deleteCount,
             currentTaskIds: input.payload.currentTaskIds,
             currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
             currentTaskChangeKeys: input.payload.currentTaskChangeKeys ?? new Map(),
+            currentTaskRelationshipChangeKeys: input.payload.currentTaskRelationshipChangeKeys ?? new Map(),
+            currentTaxonomyChangeKey: input.payload.currentTaxonomyChangeKey ?? '',
             deleteTaskIds: input.payload.deleteTaskIds,
             currentInitiativeIds: input.payload.currentInitiativeIds,
             currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
@@ -239,6 +599,12 @@ export async function runWorkspacePushSyncService(input) {
             currentAnnotatedAttachmentSessionIds: input.payload.currentAnnotatedAttachmentSessionIds,
             deleteAnnotatedAttachmentSessionIds: input.payload.deleteAnnotatedAttachmentSessionIds,
             currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
+            currentTaskforceAgentIds: input.payload.currentTaskforceAgentIds ?? new Set(),
+            currentTaskforceAgentWatermarks: input.payload.currentTaskforceAgentWatermarks ?? new Map(),
+            currentTaskforceAgentSkillIds: input.payload.currentTaskforceAgentSkillIds ?? new Set(),
+            currentTaskforceAgentSkillWatermarks: input.payload.currentTaskforceAgentSkillWatermarks ?? new Map(),
+            currentAgentConversationIds: input.payload.currentAgentConversationIds ?? new Set(),
+            currentAgentConversationWatermarks: input.payload.currentAgentConversationWatermarks ?? new Map(),
             currentTaskEventWatermarks: input.payload.currentTaskEventWatermarks,
             pushedWatermarks: new Map(),
             pushedTaskChangeKeys: new Map(),
@@ -246,38 +612,241 @@ export async function runWorkspacePushSyncService(input) {
             appliedTaskUpserts: []
         };
     }
-    const pushData = asObjectRecord(pushResult.data);
-    const emittedEventIds = Array.isArray(pushData.emittedEventIds)
-        ? Array.from(new Set(pushData.emittedEventIds
-            .map((entry) => String(entry || '').trim())
-            .filter(Boolean)))
-        : [];
-    const appliedTaskUpserts = Array.isArray(pushData.appliedTaskUpserts)
-        ? pushData.appliedTaskUpserts
-            .map((entry) => {
-            const source = entry && typeof entry === 'object' ? entry : {};
-            const task = source.task && typeof source.task === 'object'
-                ? source.task
-                : null;
-            const taskId = String(task?.id || '').trim();
-            if (!task || !taskId)
-                return null;
-            return {
-                archived: source.archived === true,
-                task
+    const emittedEventIds = new Set();
+    const appliedTaskUpserts = [];
+    let batchOperationIdentities;
+    if (retainedPreparedPlan) {
+        // The checkpoint boundary validates the complete prepared-plan
+        // fingerprint before this service receives it. Preserve those exact
+        // operation identities: older plans were hashed before the payload
+        // codec canonicalized object-key order, so recomputing after a restart
+        // can change the hash without changing the semantic batch.
+        batchOperationIdentities = [...retainedPreparedPlan.batchOperationIdentities];
+        if (batchOperationIdentities.length !== batchPlan.batches.length
+            || new Set(batchOperationIdentities).size !== batchOperationIdentities.length
+            || batchOperationIdentities.some((identity) => !/^[a-f0-9]{64}$/.test(identity))) {
+            throw new Error('Persisted V2 push prepared plan fingerprint does not match its frozen batches.');
+        }
+    }
+    else {
+        batchOperationIdentities = await Promise.all(batchPlan.batches.map((batch) => computeIdempotencyKey(input.workspaceId, batch.map((entry) => entry.plain), input.repairMode === true)));
+        const preparedEntries = buildPreparedPlanEntries(input.payload.changes, preparedChanges);
+        retainedPreparedPlan = {
+            contractVersion: WORKSPACE_PUSH_PREPARED_PLAN_VERSION,
+            ownership: preparedOwnership,
+            batches: batchPlan.batches.map((batch) => batch.map((entry) => preparedEntries[entry.preparedIndex])),
+            batchOperationIdentities: [...batchOperationIdentities],
+        };
+    }
+    const pushBoundary = createWorkspaceSyncEngineV2PushBoundary(batchOperationIdentities);
+    const requestedAcknowledgements = input.acknowledgedNonApplyingBatchOperationIdentities || [];
+    if (new Set(requestedAcknowledgements).size !== requestedAcknowledgements.length) {
+        throw new Error('Persisted V2 push batch acknowledgement state does not match the frozen push plan.');
+    }
+    for (const identity of requestedAcknowledgements) {
+        const batchIndex = batchOperationIdentities.indexOf(identity);
+        if (batchIndex >= 0 && workspaceSyncEngineExpectedTaskEchoIds(batchPlan.batches[batchIndex].map((entry) => entry.plain)).length > 0) {
+            throw new Error('Persisted V2 push batch acknowledgement state does not match the frozen push plan.');
+        }
+    }
+    const validAcknowledgements = requestedAcknowledgements.filter((identity) => {
+        const batchIndex = batchOperationIdentities.indexOf(identity);
+        return batchIndex >= 0 && workspaceSyncEngineExpectedTaskEchoIds(batchPlan.batches[batchIndex].map((entry) => entry.plain)).length === 0;
+    });
+    const replayedLegacyAcknowledgementIdentities = input.preparedPlan
+        ? []
+        : requestedAcknowledgements.filter((identity) => !validAcknowledgements.includes(identity));
+    if (retainedPreparedPlan && !input.preparedPlan) {
+        await input.onPreparedPlan?.({
+            plan: retainedPreparedPlan,
+            acknowledgedOperationIdentities: validAcknowledgements,
+            replayedLegacyAcknowledgementIdentities,
+        });
+    }
+    const acknowledgedNonApplyingBatchOperationIdentities = new Set(validAcknowledgements);
+    if (input.preparedPlan
+        && acknowledgedNonApplyingBatchOperationIdentities.size !== requestedAcknowledgements.length) {
+        throw new Error('Persisted V2 push batch acknowledgement state does not match the frozen push plan.');
+    }
+    let completedBatchCount = 0;
+    let completedChangeCount = 0;
+    const pushTransferReceipts = [];
+    const abandonRetainedPushReceipts = async (errorCode) => {
+        if (pushTransferReceipts.length === 0)
+            return;
+        const receipts = pushTransferReceipts.splice(0);
+        await remoteServices.abandonTransferReceipts({
+            workspaceId: input.workspaceId,
+            receipts,
+            errorCode,
+        });
+    };
+    try {
+        for (const [batchIndex, batch] of batchPlan.batches.entries()) {
+            const plainBatchChanges = batch.map((entry) => entry.plain);
+            const safeBatchChanges = batch.map((entry) => entry.safe);
+            const expectedTaskEchoIds = workspaceSyncEngineExpectedTaskEchoIds(plainBatchChanges);
+            const idempotencyKey = batchOperationIdentities[batchIndex];
+            if (acknowledgedNonApplyingBatchOperationIdentities.has(idempotencyKey)) {
+                completedBatchCount += 1;
+                completedChangeCount += plainBatchChanges.length;
+                continue;
+            }
+            if (pushTransferReceipts.length > 0) {
+                await remoteServices.retainTransferReceipts?.({
+                    workspaceId: input.workspaceId,
+                    receipts: pushTransferReceipts,
+                });
+            }
+            const sendPush = async () => {
+                const requestStartedAtMs = Date.now();
+                const result = await remoteServices.pushWorkspaceChanges({
+                    workspaceId: input.workspaceId,
+                    idempotencyKey,
+                    pushBoundary,
+                    changes: safeBatchChanges,
+                    ownership: preparedOwnership,
+                    repairMode: input.repairMode === true,
+                });
+                requestMs += (Date.now() - requestStartedAtMs);
+                return result;
             };
-        })
-            .filter((entry) => Boolean(entry))
-        : [];
+            let pushResult = await sendPush();
+            let pushErrorData = asObjectRecord(pushResult.data);
+            let pushInProgress = pushResult.status === 409 && pushErrorData.code === 'SYNC_PUSH_IN_PROGRESS';
+            if (!pushResult.ok && !pushInProgress && (pushResult.status === 403 || pushResult.status === 409)) {
+                const ensured = await input.ensureCloudWorkspaceReadyForSync();
+                if (ensured.success) {
+                    pushResult = await sendPush();
+                    pushErrorData = asObjectRecord(pushResult.data);
+                    pushInProgress = pushResult.status === 409 && pushErrorData.code === 'SYNC_PUSH_IN_PROGRESS';
+                }
+            }
+            if (pushResult.transferReceipt) {
+                pushTransferReceipts.push(pushResult.transferReceipt);
+            }
+            if (!pushResult.ok) {
+                await abandonRetainedPushReceipts('WORKSPACE_SYNC_V2_PUSH_ATTEMPT_FAILED');
+                const data = asObjectRecord(pushResult.data);
+                const failedOperations = Array.from(new Set(plainBatchChanges.map((change) => change.op)));
+                const failedContentChanges = plainBatchChanges.filter(isWorkspacePushContentChange).length;
+                return {
+                    success: false,
+                    status: pushResult.status,
+                    error: typeof data.error === 'string' ? data.error : undefined,
+                    code: typeof data.code === 'string' ? data.code : undefined,
+                    batchProgress: {
+                        totalBatches: batchPlan.batches.length,
+                        completedBatches: completedBatchCount,
+                        completedChanges: completedChangeCount,
+                        failedBatchIndex: batchIndex,
+                        failedChangeCount: plainBatchChanges.length,
+                        failedOperations,
+                        failureDomain: failedContentChanges === plainBatchChanges.length
+                            ? 'content'
+                            : failedContentChanges === 0
+                                ? 'metadata'
+                                : 'mixed',
+                    },
+                    retryAfterMs: pushResult.retryAfterMs,
+                    transient: pushInProgress || isTransientWorkspaceSyncStatus(pushResult.status),
+                    requestMs,
+                    changeCount,
+                    deleteCount,
+                    currentTaskIds: input.payload.currentTaskIds,
+                    currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
+                    currentTaskChangeKeys: input.payload.currentTaskChangeKeys ?? new Map(),
+                    currentTaskRelationshipChangeKeys: input.payload.currentTaskRelationshipChangeKeys ?? new Map(),
+                    currentTaxonomyChangeKey: input.payload.currentTaxonomyChangeKey ?? '',
+                    deleteTaskIds: input.payload.deleteTaskIds,
+                    currentInitiativeIds: input.payload.currentInitiativeIds,
+                    currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
+                    currentWorkstreamIds: input.payload.currentWorkstreamIds,
+                    currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+                    currentAiProfileIds: input.payload.currentAiProfileIds,
+                    currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
+                    currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
+                    currentDocumentPaths: input.payload.currentDocumentPaths,
+                    deleteDocumentPaths: input.payload.deleteDocumentPaths,
+                    currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
+                    currentAssetPaths: input.payload.currentAssetPaths,
+                    deleteAssetPaths: input.payload.deleteAssetPaths,
+                    currentAssetWatermarks: input.payload.currentAssetWatermarks,
+                    currentDocumentReviewSessionIds: input.payload.currentDocumentReviewSessionIds,
+                    deleteDocumentReviewSessionIds: input.payload.deleteDocumentReviewSessionIds,
+                    currentDocumentReviewSessionWatermarks: input.payload.currentDocumentReviewSessionWatermarks,
+                    currentDocumentReviewCommentIds: input.payload.currentDocumentReviewCommentIds,
+                    deleteDocumentReviewCommentIds: input.payload.deleteDocumentReviewCommentIds,
+                    currentDocumentReviewCommentWatermarks: input.payload.currentDocumentReviewCommentWatermarks,
+                    currentAnnotatedAttachmentSessionIds: input.payload.currentAnnotatedAttachmentSessionIds,
+                    deleteAnnotatedAttachmentSessionIds: input.payload.deleteAnnotatedAttachmentSessionIds,
+                    currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
+                    currentTaskforceAgentIds: input.payload.currentTaskforceAgentIds ?? new Set(),
+                    currentTaskforceAgentWatermarks: input.payload.currentTaskforceAgentWatermarks ?? new Map(),
+                    currentTaskforceAgentSkillIds: input.payload.currentTaskforceAgentSkillIds ?? new Set(),
+                    currentTaskforceAgentSkillWatermarks: input.payload.currentTaskforceAgentSkillWatermarks ?? new Map(),
+                    currentAgentConversationIds: input.payload.currentAgentConversationIds ?? new Set(),
+                    currentAgentConversationWatermarks: input.payload.currentAgentConversationWatermarks ?? new Map(),
+                    currentTaskEventWatermarks: input.payload.currentTaskEventWatermarks,
+                    pushedWatermarks: new Map(),
+                    pushedTaskChangeKeys: new Map(),
+                    emittedEventIds: [],
+                    appliedTaskUpserts: []
+                };
+            }
+            const pushData = asObjectRecord(pushResult.data);
+            if (Array.isArray(pushData.emittedEventIds)) {
+                for (const eventId of pushData.emittedEventIds
+                    .map((entry) => String(entry || '').trim())
+                    .filter(Boolean)) {
+                    emittedEventIds.add(eventId);
+                }
+            }
+            const normalizedTaskUpserts = parseWorkspaceSyncEngineAppliedTaskUpserts(pushData, expectedTaskEchoIds);
+            appliedTaskUpserts.push(...normalizedTaskUpserts);
+            if (pushResult.transferReceipt && normalizedTaskUpserts.length === 0) {
+                await remoteServices.acknowledgeNonApplyingTransferReceipts({
+                    workspaceId: input.workspaceId,
+                    receipts: [pushResult.transferReceipt],
+                });
+                const receiptIndex = pushTransferReceipts.indexOf(pushResult.transferReceipt);
+                if (receiptIndex >= 0)
+                    pushTransferReceipts.splice(receiptIndex, 1);
+                acknowledgedNonApplyingBatchOperationIdentities.add(idempotencyKey);
+                await input.onNonApplyingBatchAcknowledged?.({
+                    operationIdentity: idempotencyKey,
+                    acknowledgedOperationIdentities: batchOperationIdentities.filter((identity) => acknowledgedNonApplyingBatchOperationIdentities.has(identity)),
+                });
+            }
+            completedBatchCount += 1;
+            completedChangeCount += plainBatchChanges.length;
+        }
+    }
+    catch (error) {
+        await abandonRetainedPushReceipts('WORKSPACE_SYNC_V2_PUSH_ATTEMPT_FAILED');
+        throw error;
+    }
     return {
         success: true,
         syncedAt: new Date().toISOString(),
         requestMs,
         changeCount,
+        batchProgress: {
+            totalBatches: batchPlan.batches.length,
+            completedBatches: completedBatchCount,
+            completedChanges: completedChangeCount,
+            failedBatchIndex: null,
+            failedChangeCount: 0,
+            failedOperations: [],
+            failureDomain: null,
+        },
+        effectiveDeltaDiagnostics,
         deleteCount,
         currentTaskIds: input.payload.currentTaskIds,
         currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
         currentTaskChangeKeys: input.payload.currentTaskChangeKeys ?? new Map(),
+        currentTaskRelationshipChangeKeys: input.payload.currentTaskRelationshipChangeKeys ?? new Map(),
+        currentTaxonomyChangeKey: input.payload.currentTaxonomyChangeKey ?? '',
         deleteTaskIds: input.payload.deleteTaskIds,
         currentInitiativeIds: input.payload.currentInitiativeIds,
         currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
@@ -301,14 +870,54 @@ export async function runWorkspacePushSyncService(input) {
         currentAnnotatedAttachmentSessionIds: input.payload.currentAnnotatedAttachmentSessionIds,
         deleteAnnotatedAttachmentSessionIds: input.payload.deleteAnnotatedAttachmentSessionIds,
         currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
+        currentTaskforceAgentIds: input.payload.currentTaskforceAgentIds ?? new Set(),
+        currentTaskforceAgentWatermarks: input.payload.currentTaskforceAgentWatermarks ?? new Map(),
+        currentTaskforceAgentSkillIds: input.payload.currentTaskforceAgentSkillIds ?? new Set(),
+        currentTaskforceAgentSkillWatermarks: input.payload.currentTaskforceAgentSkillWatermarks ?? new Map(),
+        currentAgentConversationIds: input.payload.currentAgentConversationIds ?? new Set(),
+        currentAgentConversationWatermarks: input.payload.currentAgentConversationWatermarks ?? new Map(),
         currentTaskEventWatermarks: input.payload.currentTaskEventWatermarks,
         pushedWatermarks: input.payload.pushedWatermarks,
         pushedTaskChangeKeys: input.payload.pushedTaskChangeKeys ?? new Map(),
-        emittedEventIds,
-        appliedTaskUpserts
+        emittedEventIds: Array.from(emittedEventIds),
+        appliedTaskUpserts,
+        pushBoundary,
+        pushTransferReceipts,
     };
 }
 export async function runWorkspacePullSyncService(input) {
+    const remoteServices = input.remoteServices
+        || createBrowserWorkspaceSyncEngineRemoteServices(input.resolveCloudAuthUrl);
+    let activeTransferReceipts = [];
+    const captureTransferReceipt = (response) => {
+        if (response.transferReceipt)
+            activeTransferReceipts.push(response.transferReceipt);
+    };
+    const abandonActiveTransferReceipts = async (errorCode) => {
+        if (activeTransferReceipts.length === 0)
+            return;
+        const receipts = activeTransferReceipts;
+        await remoteServices.abandonTransferReceipts({
+            workspaceId: input.workspaceId,
+            receipts,
+            errorCode,
+        });
+        activeTransferReceipts = [];
+    };
+    const readContentManifest = input.localServices?.readContentManifest
+        || getLocalWorkspaceContentManifest;
+    const applyV2Batch = input.localServices?.applyV2Batch
+        || applyLocalWorkspaceChanges;
+    const listContentPullObligations = input.localServices?.listContentPullObligations
+        || getLocalWorkspaceContentPullObligations;
+    const recordContentPullObligationFailures = input.localServices?.recordContentPullObligationFailures
+        || recordLocalWorkspaceContentPullObligationFailures;
+    const persistContentPullFailure = async (obligationIds, error) => {
+        const result = await recordContentPullObligationFailures(input.workspaceId, obligationIds, error);
+        if (!result.ok) {
+            throw new Error(String(result.data?.error || 'Failed to persist content-pull retry state.'));
+        }
+    };
     let cursor = input.cursor;
     let hasMore = true;
     let pages = 0;
@@ -320,32 +929,224 @@ export async function runWorkspacePullSyncService(input) {
     let pulledArchivedUpserts = false;
     let pulledTaskEventUpserts = false;
     let pulledPlanningUpserts = false;
+    let pulledTaskforceAgentUpserts = false;
+    let pulledAgentRoleUpserts = false;
+    let pulledTaskforceAgentSkillUpserts = false;
+    let pulledAgentConversationUpserts = false;
     const documentDecryptFailures = new Set();
     const emittedEventIds = new Set();
     const pulledAnnotatedAttachmentSessionIds = new Set();
     let lastServerDiagnostics = null;
+    const contentReconciliationDiagnostics = {
+        manifestEntries: 0,
+        bodiesRequested: 0,
+        bodiesTransferred: 0,
+        contentBytesTransferred: 0,
+        contentBytesAvoided: 0,
+        obligationsAttempted: 0,
+        obligationsResolved: 0,
+        obligationsRemaining: 0,
+    };
     const maxPages = Number.isFinite(Number(input.maxPages)) ? Math.max(1, Math.floor(Number(input.maxPages))) : 20;
+    let localContentManifest = new Map();
+    const openContentPullObligationIds = new Set();
     try {
+        {
+            const obligationsResponse = await listContentPullObligations(input.workspaceId, 100);
+            if (!obligationsResponse.ok) {
+                throw new Error(String(obligationsResponse.data?.error
+                    || `Local content-pull obligation read failed (${obligationsResponse.status}).`));
+            }
+            const openObligations = Array.isArray(obligationsResponse.data?.obligations)
+                ? obligationsResponse.data.obligations
+                : [];
+            openObligations.forEach((obligation) => {
+                openContentPullObligationIds.add(workspaceSyncContentPullObligationId(obligation));
+            });
+            const obligations = openObligations.filter((obligation) => (isContentPullObligationDue(obligation)));
+            contentReconciliationDiagnostics.obligationsAttempted = obligations.length;
+            if (obligations.length > 0) {
+                const contentResponse = await remoteServices.pullWorkspaceContent({
+                    workspaceId: input.workspaceId,
+                    requests: obligations.map(({ kind, path }) => ({ kind, path })),
+                    previousCursor: cursor,
+                });
+                captureTransferReceipt(contentResponse);
+                if (contentResponse.ok) {
+                    const contentData = contentResponse.data || {};
+                    const hydratedChanges = Array.isArray(contentData.changes) ? contentData.changes : [];
+                    const metadataEntries = Array.isArray(contentData.contentMetadata)
+                        ? contentData.contentMetadata
+                        : [];
+                    const authoritativeMetadata = new Map(metadataEntries.map((entry) => [`${entry.kind}:${entry.path}`, entry]));
+                    const obligationById = new Map(obligations.map((obligation) => [
+                        workspaceSyncContentPullObligationId(obligation),
+                        obligation,
+                    ]));
+                    if (authoritativeMetadata.size !== metadataEntries.length
+                        || metadataEntries.some((entry) => (!obligationById.has(`${entry.kind}:${entry.path}`)))) {
+                        await persistContentPullFailure(obligations.map(workspaceSyncContentPullObligationId), 'Content response contained duplicate or unexpected authoritative metadata.');
+                        throw new Error('Workspace content obligation response contained invalid authoritative metadata.');
+                    }
+                    const resolvedIds = [];
+                    const resolutionClaims = [];
+                    for (const change of hydratedChanges) {
+                        if (change.op !== 'document-upsert' && change.op !== 'asset-upsert') {
+                            await persistContentPullFailure(obligations.map(workspaceSyncContentPullObligationId), `Content response contained invalid operation ${change.op}.`);
+                            throw new Error(`Workspace content obligation returned invalid operation: ${change.op}.`);
+                        }
+                        const kind = change.op === 'document-upsert' ? 'document' : 'asset';
+                        const obligationId = `${kind}:${change.path}`;
+                        if (!obligationById.has(obligationId)) {
+                            await persistContentPullFailure(obligations.map(workspaceSyncContentPullObligationId), `Content response contained unexpected body ${obligationId}.`);
+                            throw new Error(`Workspace content obligation returned an unexpected body: ${obligationId}.`);
+                        }
+                        const metadata = authoritativeMetadata.get(obligationId);
+                        if (!metadata) {
+                            await persistContentPullFailure([obligationId], 'Content response omitted authoritative metadata.');
+                            throw new Error(`Workspace content obligation omitted authoritative metadata: ${obligationId}.`);
+                        }
+                        if (resolvedIds.includes(obligationId)) {
+                            await persistContentPullFailure([obligationId], 'Content response contained a duplicate body.');
+                            throw new Error(`Workspace content obligation returned a duplicate body: ${obligationId}.`);
+                        }
+                        if (typeof process !== 'undefined'
+                            && process.env?.TASKFORCE_SYNC_KEY) {
+                            try {
+                                await decryptWorkspaceSyncContentChangeInPlace(change, process.env.TASKFORCE_SYNC_KEY);
+                            }
+                            catch (error) {
+                                await persistContentPullFailure([obligationId], String(error?.message || 'Content decryption failed.'));
+                                throw error;
+                            }
+                        }
+                        const actual = await fingerprintWorkspaceContentBody(kind, change.op === 'document-upsert' ? change.content : change.contentBase64);
+                        if (actual.sha256 !== String(metadata.sha256 || '').toLowerCase()
+                            || actual.sizeBytes !== Number(metadata.sizeBytes)
+                            || String(metadata.updatedAt || '') < String(obligationById.get(obligationId)?.sourceWatermark || '')
+                            || String(change.updatedAt || '') < String(obligationById.get(obligationId)?.sourceWatermark || '')) {
+                            await persistContentPullFailure([obligationId], 'Authoritative content response was stale or failed verification.');
+                            throw new Error(`Workspace content obligation verification failed: ${obligationId}.`);
+                        }
+                        resolvedIds.push(obligationId);
+                        const obligation = obligationById.get(obligationId);
+                        resolutionClaims.push({
+                            kind,
+                            path: change.path,
+                            resolution: 'exact-version',
+                            sourceWatermark: obligation.sourceWatermark,
+                            metadataFingerprint: obligation.metadataFingerprint,
+                        });
+                    }
+                    if (hydratedChanges.length > 0) {
+                        const completionGroup = activeTransferReceipts.length > 0
+                            ? remoteServices.buildV2ApplyCompletionGroup({
+                                workspaceId: input.workspaceId,
+                                previousCursor: cursor,
+                                nextCursor: cursor,
+                                receipts: activeTransferReceipts,
+                            })
+                            : undefined;
+                        if (activeTransferReceipts.length > 0 && !completionGroup) {
+                            throw new Error('Content-obligation receipts did not produce an apply completion group.');
+                        }
+                        let applyResult;
+                        try {
+                            applyResult = await applyV2Batch(input.workspaceId, hydratedChanges, {
+                                repairMode: input.repairMode === true,
+                                excludedProjections: input.excludedProjections,
+                                contentPullResolutionClaims: resolutionClaims,
+                                ...(completionGroup ? { completionGroup } : {}),
+                            });
+                        }
+                        catch (error) {
+                            await persistContentPullFailure(resolvedIds, String(error?.message || 'Content obligation apply failed.'));
+                            throw error;
+                        }
+                        if (!applyResult.ok || asObjectRecord(applyResult.data).success === false) {
+                            await persistContentPullFailure(resolvedIds, String(asObjectRecord(applyResult.data).error
+                                || 'Workspace content obligation apply failed.'));
+                            throw new Error(String(asObjectRecord(applyResult.data).error || 'Workspace content obligation apply failed.'));
+                        }
+                        activeTransferReceipts = [];
+                        contentReconciliationDiagnostics.obligationsResolved = resolvedIds.length;
+                        const unresolvedIds = obligations
+                            .map(workspaceSyncContentPullObligationId)
+                            .filter((obligationId) => !resolvedIds.includes(obligationId));
+                        if (unresolvedIds.length > 0) {
+                            await persistContentPullFailure(unresolvedIds, 'Authoritative content body remains unavailable.');
+                        }
+                    }
+                    else {
+                        if (activeTransferReceipts.length > 0) {
+                            const completionGroup = remoteServices.buildV2ApplyCompletionGroup({
+                                workspaceId: input.workspaceId,
+                                previousCursor: cursor,
+                                nextCursor: cursor,
+                                receipts: activeTransferReceipts,
+                            });
+                            if (!completionGroup) {
+                                throw new Error('Unavailable content receipts did not produce an apply completion group.');
+                            }
+                            const applyResult = await applyV2Batch(input.workspaceId, [], {
+                                repairMode: input.repairMode === true,
+                                excludedProjections: input.excludedProjections,
+                                completionGroup,
+                            });
+                            if (!applyResult.ok || asObjectRecord(applyResult.data).success === false) {
+                                throw new Error(String(asObjectRecord(applyResult.data).error
+                                    || 'Unavailable content receipt settlement failed.'));
+                            }
+                            activeTransferReceipts = [];
+                        }
+                        await persistContentPullFailure(obligations.map(workspaceSyncContentPullObligationId), 'Authoritative content body remains unavailable.');
+                    }
+                }
+                else {
+                    await abandonActiveTransferReceipts('WORKSPACE_SYNC_CONTENT_OBLIGATION_RETRY');
+                    await persistContentPullFailure(obligations.map(workspaceSyncContentPullObligationId), String(asObjectRecord(contentResponse.data).error
+                        || `Content pull failed (${contentResponse.status}).`));
+                }
+            }
+            contentReconciliationDiagnostics.obligationsRemaining = Math.max(0, openObligations.length - contentReconciliationDiagnostics.obligationsResolved);
+        }
+        if (input.contentMode === 'manifest') {
+            const localManifestResponse = await readContentManifest(input.workspaceId);
+            if (!localManifestResponse.ok) {
+                throw new Error(`Local workspace content manifest failed (${localManifestResponse.status || 0}).`);
+            }
+            const localEntries = Array.isArray(localManifestResponse.data?.entries)
+                ? localManifestResponse.data.entries
+                : [];
+            localContentManifest = new Map(localEntries.map((entry) => [`${entry.kind}:${entry.path}`, entry]));
+        }
         while (hasMore && pages < maxPages) {
             const requestPull = async () => {
                 const pullRequestStartedAtMs = Date.now();
-                const result = await pullWorkspaceChanges(input.resolveCloudAuthUrl, {
+                const result = await remoteServices.pullWorkspaceChanges({
                     workspaceId: input.workspaceId,
                     cursor,
                     limit: input.bootstrap ? 500 : 200,
-                    repairMode: input.repairMode === true
+                    repairMode: input.repairMode === true,
+                    contentMode: input.contentMode,
+                    excludeInitiatives: input.excludeInitiatives,
+                    excludedProjections: input.excludedProjections,
                 });
                 pullRequestMs += (Date.now() - pullRequestStartedAtMs);
                 return result;
             };
             let pullRes = await requestPull();
+            captureTransferReceipt(pullRes);
             if (!pullRes.ok && pullRes.status === 403 && input.ensureCloudWorkspaceReadyForSync) {
                 const ensured = await input.ensureCloudWorkspaceReadyForSync();
                 if (ensured.success) {
+                    await abandonActiveTransferReceipts('WORKSPACE_SYNC_V2_PULL_RETRY');
                     pullRes = await requestPull();
+                    captureTransferReceipt(pullRes);
                 }
             }
             if (!pullRes.ok) {
+                await abandonActiveTransferReceipts('WORKSPACE_SYNC_V2_PULL_REJECTED');
                 const pullErrorData = asObjectRecord(pullRes.data);
                 return {
                     success: false,
@@ -365,12 +1166,111 @@ export async function runWorkspacePullSyncService(input) {
                     pulledArchivedUpserts,
                     pulledTaskEventUpserts,
                     pulledPlanningUpserts,
+                    pulledTaskforceAgentUpserts,
+                    pulledTaskforceAgentSkillUpserts,
+                    pulledAgentConversationUpserts,
                     documentDecryptFailures: Array.from(documentDecryptFailures),
                     serverDiagnostics: null
                 };
             }
             const pullData = pullRes.data || {};
-            const changes = Array.isArray(pullData?.changes) ? pullData.changes : [];
+            if (!workspaceSyncV2ProjectionExclusionsEqual(pullData.excludedProjections, input.excludedProjections)) {
+                await abandonActiveTransferReceipts('SYNC_V2_PROJECTION_EXCLUSIONS_MISMATCH');
+                return {
+                    success: false,
+                    kind: 'pull_http',
+                    status: 502,
+                    errorCode: 'SYNC_V2_PROJECTION_EXCLUSIONS_MISMATCH',
+                    error: 'Cloud pull did not attest the requested v2 projection exclusions.',
+                    transient: false,
+                    cursor, pages, appliedChanges, pullRequestMs, applyMs, pulledDeleteTaskIds,
+                    pulledActiveUpserts, pulledArchivedUpserts, pulledTaskEventUpserts,
+                    pulledPlanningUpserts, pulledTaskforceAgentUpserts, pulledTaskforceAgentSkillUpserts, pulledAgentConversationUpserts,
+                    documentDecryptFailures: Array.from(documentDecryptFailures), serverDiagnostics: null,
+                };
+            }
+            let changes = Array.isArray(pullData?.changes) ? pullData.changes : [];
+            const expectedContent = new Map();
+            const contentPullObligations = [];
+            if (input.contentMode === 'manifest') {
+                const requestedContent = [];
+                const nonManifestChanges = [];
+                for (const change of changes) {
+                    if (change.op !== 'document-manifest' && change.op !== 'asset-manifest') {
+                        nonManifestChanges.push(change);
+                        continue;
+                    }
+                    const manifest = change.manifest;
+                    contentReconciliationDiagnostics.manifestEntries += 1;
+                    if (!manifest.existsLocally) {
+                        contentPullObligations.push({
+                            manifest,
+                            sourceWatermark: manifest.updatedAt,
+                        });
+                        openContentPullObligationIds.add(`${manifest.kind}:${manifest.path}`);
+                        continue;
+                    }
+                    const key = `${manifest.kind}:${manifest.path}`;
+                    const decision = decideWorkspaceContentFetch(manifest, localContentManifest.get(key));
+                    if (!decision.shouldFetch) {
+                        contentReconciliationDiagnostics.contentBytesAvoided += Math.max(0, manifest.sizeBytes);
+                    }
+                    else if (decision.reasons.every((reason) => reason === 'metadata-mismatch')) {
+                        nonManifestChanges.push(change);
+                        contentReconciliationDiagnostics.contentBytesAvoided += Math.max(0, manifest.sizeBytes);
+                    }
+                    else {
+                        requestedContent.push({ kind: manifest.kind, path: manifest.path });
+                        expectedContent.set(key, manifest);
+                        contentReconciliationDiagnostics.bodiesRequested += 1;
+                    }
+                }
+                const pendingRequests = [...requestedContent];
+                while (pendingRequests.length > 0) {
+                    let remaining = pendingRequests.splice(0, 100);
+                    while (remaining.length > 0) {
+                        const contentResponse = await remoteServices.pullWorkspaceContent({
+                            workspaceId: input.workspaceId,
+                            requests: remaining,
+                            previousCursor: cursor,
+                        });
+                        if (!contentResponse.ok) {
+                            captureTransferReceipt(contentResponse);
+                            throw new Error(`Workspace content pull failed (${contentResponse.status || 0}).`);
+                        }
+                        captureTransferReceipt(contentResponse);
+                        const contentData = contentResponse.data || {};
+                        const hydratedChanges = Array.isArray(contentData.changes) ? contentData.changes : [];
+                        const missing = Array.isArray(contentData.missing) ? contentData.missing : [];
+                        if (missing.length > 0) {
+                            const missingIdentity = 'path' in missing[0] ? missing[0].path : missing[0].assetId;
+                            throw new Error(`Workspace content changed or disappeared during reconciliation: ${missing[0].kind}:${missingIdentity}`);
+                        }
+                        nonManifestChanges.push(...hydratedChanges);
+                        const nextRemaining = Array.isArray(contentData.remaining) ? contentData.remaining : [];
+                        if (hydratedChanges.length === 0 && nextRemaining.length >= remaining.length) {
+                            throw new Error('Workspace content pull made no progress.');
+                        }
+                        remaining = nextRemaining;
+                    }
+                }
+                changes = nonManifestChanges;
+            }
+            else {
+                const applicableChanges = [];
+                for (const change of changes) {
+                    if (change.op !== 'document-manifest' && change.op !== 'asset-manifest') {
+                        applicableChanges.push(change);
+                        continue;
+                    }
+                    contentPullObligations.push({
+                        manifest: change.manifest,
+                        sourceWatermark: change.manifest.updatedAt,
+                    });
+                    openContentPullObligationIds.add(`${change.manifest.kind}:${change.manifest.path}`);
+                }
+                changes = applicableChanges;
+            }
             const serverDiagnostics = pullData?.diagnostics && typeof pullData.diagnostics === 'object'
                 ? pullData.diagnostics
                 : null;
@@ -402,10 +1302,26 @@ export async function runWorkspacePullSyncService(input) {
                     pulledPlanningUpserts = true;
                     continue;
                 }
+                if (change.op === 'taskforce-agent-upsert') {
+                    pulledTaskforceAgentUpserts = true;
+                    continue;
+                }
+                if (change.op === 'agent-role-upsert') {
+                    pulledAgentRoleUpserts = true;
+                    continue;
+                }
+                if (change.op === 'taskforce-agent-skill-upsert') {
+                    pulledTaskforceAgentSkillUpserts = true;
+                    continue;
+                }
+                if (change.op === 'agent-conversation-upsert') {
+                    pulledAgentConversationUpserts = true;
+                    continue;
+                }
                 if (change.op === 'document-upsert') {
                     if (typeof change.content === 'string' && typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
                         try {
-                            change.content = await decryptDocument(change.content, process.env.TASKFORCE_SYNC_KEY);
+                            await decryptWorkspaceSyncContentChangeInPlace(change, process.env.TASKFORCE_SYNC_KEY);
                         }
                         catch {
                             // Leave encrypted content as fallback if decryption fails (e.g., bad key) so we don't drop the document entirely.
@@ -419,7 +1335,7 @@ export async function runWorkspacePullSyncService(input) {
                 if (change.op === 'asset-upsert') {
                     if (typeof change.contentBase64 === 'string' && typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
                         try {
-                            change.contentBase64 = await decryptDocument(change.contentBase64, process.env.TASKFORCE_SYNC_KEY);
+                            await decryptWorkspaceSyncContentChangeInPlace(change, process.env.TASKFORCE_SYNC_KEY);
                         }
                         catch {
                             // Leave as-is on decrypt failure so the asset entry is not silently dropped.
@@ -436,17 +1352,86 @@ export async function runWorkspacePullSyncService(input) {
                 if (deleteTaskId)
                     pulledDeleteTaskIds.add(deleteTaskId);
             }
+            if (input.contentMode === 'manifest' && expectedContent.size > 0) {
+                const verifiedContent = new Set();
+                for (const change of changes) {
+                    if (change.op !== 'document-upsert' && change.op !== 'asset-upsert')
+                        continue;
+                    const kind = change.op === 'document-upsert' ? 'document' : 'asset';
+                    const expected = expectedContent.get(`${kind}:${change.path}`);
+                    if (!expected)
+                        continue;
+                    const actual = await fingerprintWorkspaceContentBody(kind, change.op === 'document-upsert' ? change.content : change.contentBase64);
+                    if ((expected.sha256 && actual.sha256 !== expected.sha256.toLowerCase())
+                        || actual.sizeBytes !== expected.sizeBytes) {
+                        throw new Error(`Workspace content verification failed for ${kind}:${change.path}.`);
+                    }
+                    verifiedContent.add(`${kind}:${change.path}`);
+                    contentReconciliationDiagnostics.bodiesTransferred += 1;
+                    contentReconciliationDiagnostics.contentBytesTransferred += actual.sizeBytes;
+                }
+                if (verifiedContent.size !== expectedContent.size) {
+                    throw new Error('Workspace content pull did not return every requested body.');
+                }
+            }
             if (input.onPagePulled)
                 input.onPagePulled();
-            if (changes.length > 0 || hasWorkspaceMembersSnapshot) {
+            const nextCursor = pullData && 'nextCursor' in pullData
+                && (pullData.nextCursor === null || typeof pullData.nextCursor === 'string')
+                ? pullData.nextCursor
+                : cursor;
+            const contentPullResolutionClaims = changes.flatMap((change) => {
+                if (change.op !== 'document-delete' && change.op !== 'asset-delete')
+                    return [];
+                if (!change.deletedAt)
+                    return [];
+                const kind = change.op === 'document-delete' ? 'document' : 'asset';
+                return [{
+                        kind,
+                        path: change.path,
+                        resolution: 'at-or-before-watermark',
+                        sourceWatermark: change.deletedAt,
+                    }];
+            });
+            const isCompleteBootstrapPage = input.bootstrap && !Boolean(pullData?.hasMore);
+            const completionGroup = activeTransferReceipts.length > 0
+                ? remoteServices.buildV2ApplyCompletionGroup({
+                    workspaceId: input.workspaceId,
+                    previousCursor: cursor,
+                    nextCursor,
+                    receipts: activeTransferReceipts,
+                })
+                : undefined;
+            if (activeTransferReceipts.length > 0 && !completionGroup) {
+                throw new Error('V2 sync transfer receipts did not produce an apply completion group.');
+            }
+            if (changes.length > 0
+                || contentPullObligations.length > 0
+                || hasWorkspaceMembersSnapshot
+                || completionGroup
+                || isCompleteBootstrapPage) {
                 const applyStartedAtMs = Date.now();
-                const applyResult = await applyLocalWorkspaceChanges(input.workspaceId, changes, {
+                const applyResult = await applyV2Batch(input.workspaceId, changes, {
                     ...(hasWorkspaceMembersSnapshot ? { workspaceMembers } : {}),
-                    repairMode: input.repairMode === true
+                    repairMode: input.repairMode === true,
+                    excludedProjections: input.excludedProjections,
+                    ...(isCompleteBootstrapPage
+                        ? {
+                            bootstrapSnapshot: {
+                                currentAnnotatedAttachmentSessionIds: Array.from(pulledAnnotatedAttachmentSessionIds),
+                            },
+                        }
+                        : {}),
+                    ...(completionGroup ? { completionGroup } : {}),
+                    ...(contentPullObligations.length > 0 ? { contentPullObligations } : {}),
+                    ...(contentPullResolutionClaims.length > 0
+                        ? { contentPullResolutionClaims }
+                        : {}),
                 });
                 const applyFailures = applyResult.failures;
                 if (!applyResult.ok) {
                     applyMs += (Date.now() - applyStartedAtMs);
+                    await abandonActiveTransferReceipts('WORKSPACE_SYNC_V2_APPLY_NOT_COMMITTED');
                     const applyPayloadData = asObjectRecord(applyResult.data);
                     const hasAuthFailure = applyFailures.some((entry) => entry.endsWith(':401'));
                     if (hasAuthFailure) {
@@ -465,6 +1450,10 @@ export async function runWorkspacePullSyncService(input) {
                             pulledActiveUpserts,
                             pulledArchivedUpserts,
                             pulledTaskEventUpserts,
+                            pulledPlanningUpserts,
+                            pulledTaskforceAgentUpserts,
+                            pulledTaskforceAgentSkillUpserts,
+                            pulledAgentConversationUpserts,
                             documentDecryptFailures: Array.from(documentDecryptFailures),
                             serverDiagnostics
                         };
@@ -494,6 +1483,9 @@ export async function runWorkspacePullSyncService(input) {
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
                         pulledPlanningUpserts,
+                        pulledTaskforceAgentUpserts,
+                        pulledTaskforceAgentSkillUpserts,
+                        pulledAgentConversationUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -502,6 +1494,7 @@ export async function runWorkspacePullSyncService(input) {
                 const applyPayloadData = asObjectRecord(applyResult.data);
                 if (applyPayloadData.success === false) {
                     applyMs += (Date.now() - applyStartedAtMs);
+                    await abandonActiveTransferReceipts('WORKSPACE_SYNC_V2_APPLY_NOT_COMMITTED');
                     return {
                         success: false,
                         kind: 'apply_payload',
@@ -517,6 +1510,9 @@ export async function runWorkspacePullSyncService(input) {
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
                         pulledPlanningUpserts,
+                        pulledTaskforceAgentUpserts,
+                        pulledTaskforceAgentSkillUpserts,
+                        pulledAgentConversationUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -529,9 +1525,16 @@ export async function runWorkspacePullSyncService(input) {
                         emittedEventIds.add(String(eventId));
                     }
                 }
+                if (changes.some((change) => change.op === 'ai-profile-upsert')) {
+                    input.onAiProfilesApplied?.();
+                }
                 if (input.onChangesApplied)
                     input.onChangesApplied(changes.length);
+                contentPullResolutionClaims.forEach((claim) => {
+                    openContentPullObligationIds.delete(workspaceSyncContentPullObligationId(claim));
+                });
             }
+            activeTransferReceipts = [];
             if (pullData && 'nextCursor' in pullData) {
                 if (pullData.nextCursor === null || typeof pullData.nextCursor === 'string') {
                     cursor = pullData.nextCursor;
@@ -540,74 +1543,9 @@ export async function runWorkspacePullSyncService(input) {
             hasMore = Boolean(pullData?.hasMore);
             pages += 1;
         }
-        if (input.bootstrap) {
-            const bootstrapApplyStartedAtMs = Date.now();
-            const bootstrapApplyResult = await applyLocalWorkspaceChanges(input.workspaceId, [], {
-                bootstrapSnapshot: {
-                    currentAnnotatedAttachmentSessionIds: Array.from(pulledAnnotatedAttachmentSessionIds),
-                }
-            });
-            const bootstrapApplyFailures = bootstrapApplyResult.failures;
-            if (!bootstrapApplyResult.ok) {
-                applyMs += (Date.now() - bootstrapApplyStartedAtMs);
-                const applyPayloadData = asObjectRecord(bootstrapApplyResult.data);
-                const hasAuthFailure = bootstrapApplyFailures.some((entry) => entry.endsWith(':401'));
-                if (hasAuthFailure) {
-                    return {
-                        success: false,
-                        kind: 'apply_auth',
-                        status: 401,
-                        transient: false,
-                        failures: bootstrapApplyFailures,
-                        cursor,
-                        pages,
-                        appliedChanges,
-                        pullRequestMs,
-                        applyMs,
-                        pulledDeleteTaskIds,
-                        pulledActiveUpserts,
-                        pulledArchivedUpserts,
-                        pulledTaskEventUpserts,
-                        pulledPlanningUpserts,
-                        documentDecryptFailures: Array.from(documentDecryptFailures),
-                        emittedEventIds: Array.from(emittedEventIds),
-                        serverDiagnostics: lastServerDiagnostics
-                    };
-                }
-                const hasTransientApplyFailure = bootstrapApplyFailures.some((entry) => {
-                    if (entry.endsWith(':network'))
-                        return true;
-                    const statusText = entry.split(':').pop() || '';
-                    const status = Number.parseInt(statusText, 10);
-                    return Number.isFinite(status) && (status === 429 || status >= 500);
-                });
-                return {
-                    success: false,
-                    kind: 'apply_all_candidates',
-                    status: bootstrapApplyResult.status || undefined,
-                    transient: hasTransientApplyFailure,
-                    error: String(applyPayloadData.error || '').trim() || undefined,
-                    failures: bootstrapApplyFailures,
-                    hasTransientApplyFailure,
-                    cursor,
-                    pages,
-                    appliedChanges,
-                    pullRequestMs,
-                    applyMs,
-                    pulledDeleteTaskIds,
-                    pulledActiveUpserts,
-                    pulledArchivedUpserts,
-                    pulledTaskEventUpserts,
-                    pulledPlanningUpserts,
-                    documentDecryptFailures: Array.from(documentDecryptFailures),
-                    emittedEventIds: Array.from(emittedEventIds),
-                    serverDiagnostics: lastServerDiagnostics
-                };
-            }
-            applyMs += (Date.now() - bootstrapApplyStartedAtMs);
-        }
         return {
             success: true,
+            hasMore,
             syncedAt: new Date().toISOString(),
             cursor: cursor || null,
             pages,
@@ -619,18 +1557,31 @@ export async function runWorkspacePullSyncService(input) {
             pulledArchivedUpserts,
             pulledTaskEventUpserts,
             pulledPlanningUpserts,
+            pulledTaskforceAgentUpserts,
+            pulledAgentRoleUpserts,
+            pulledTaskforceAgentSkillUpserts,
+            pulledAgentConversationUpserts,
             documentDecryptFailures: Array.from(documentDecryptFailures),
             emittedEventIds: Array.from(emittedEventIds),
-            serverDiagnostics: lastServerDiagnostics
+            serverDiagnostics: input.contentMode === 'manifest'
+                ? { ...(lastServerDiagnostics || {}), contentReconciliation: contentReconciliationDiagnostics }
+                : lastServerDiagnostics
         };
     }
     catch (error) {
+        let failure = error;
+        try {
+            await abandonActiveTransferReceipts('WORKSPACE_SYNC_V2_APPLY_NOT_COMMITTED');
+        }
+        catch (settlementError) {
+            failure = settlementError;
+        }
         return {
             success: false,
             kind: 'exception',
             status: 0,
             transient: true,
-            error: String(error?.message || error || 'Workspace sync pull failed unexpectedly.'),
+            error: String(failure?.message || failure || 'Workspace sync pull failed unexpectedly.'),
             cursor: cursor || null,
             pages,
             appliedChanges,
@@ -641,9 +1592,14 @@ export async function runWorkspacePullSyncService(input) {
             pulledArchivedUpserts,
             pulledTaskEventUpserts,
             pulledPlanningUpserts,
+            pulledTaskforceAgentUpserts,
+            pulledTaskforceAgentSkillUpserts,
+            pulledAgentConversationUpserts,
             documentDecryptFailures: Array.from(documentDecryptFailures),
             emittedEventIds: Array.from(emittedEventIds),
-            serverDiagnostics: null
+            serverDiagnostics: input.contentMode === 'manifest'
+                ? { ...(lastServerDiagnostics || {}), contentReconciliation: contentReconciliationDiagnostics }
+                : lastServerDiagnostics
         };
     }
 }