@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/server/routes/sync.js

@@ -1,20 +1,27 @@
-import * as path from 'path';
 import { parseJsonBody } from './primitives.js';
-import { normalizeTaskDataRelativePath, ObjectStorageClient } from '../../storage/objectStorageClient.js';
-import { WorkspaceAssetStore, } from '../../storage/workspaceAssetStore.js';
 import { resolveSessionCookieAttributesForRequest } from '../auth.js';
 import { isAiProfileSurfaceType, parseAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
 import { isAiProfileSeatScope } from '../../shared/aiProfileSeatScope.js';
 import { serializeBinaryAssetSyncPayload, serializeDocumentSyncPayload, } from '../../sync/contentSyncPayload.js';
-import { createContentSyncState } from '../../sync/contentSyncState.js';
-import { normalizeAiProfileSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, } from '../../sync/collaborationSyncPayload.js';
-import { createCollaborationSyncState } from '../../sync/collaborationSyncState.js';
+import { normalizeAiProfileSyncPayload, normalizeAgentConversationSyncPayload, normalizeAgentRoleSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, normalizeTaskforceAgentSkillSyncPayload, normalizeTaskforceAgentSyncPayload, } from '../../sync/collaborationSyncPayload.js';
 import { normalizeInitiativeSyncPayload, normalizeTaxonomySyncPayload, normalizeWorkstreamSyncPayload, } from '../../sync/planningSyncPayload.js';
-import { applyAiProfileAndMemberSyncChanges, applyCollaborationSyncChanges, applyContentSyncChanges, applyPlanningSyncChanges, applyPreparedTaskSyncSnapshot, applyTaskActivitySyncChanges, applyTaskSyncDeletes, classifyWorkspaceSyncChanges, prepareTaskSyncSnapshotApply, } from '../../sync/syncApplyHandlers.js';
 import { registerWorkspaceSyncAuxRoutes } from './syncAuxRoutes.js';
 import { registerWorkspacePullApplySyncRoutes } from './syncPullApplyRoutes.js';
 import { registerWorkspacePushSyncRoutes } from './syncPushRoutes.js';
 import { registerWorkspaceSnapshotSyncRoutes } from './syncSnapshotRoutes.js';
+import { registerWorkspaceSyncV3OperationRoutes } from './syncV3OperationRoutes.js';
+import { registerWorkspaceSyncV3LocalCaptureRoutes } from './syncV3LocalCaptureRoutes.js';
+import { registerWorkspaceSyncV3LocalDispatchRoutes } from './syncV3LocalDispatchRoutes.js';
+import { registerWorkspaceSyncV3LocalRecoveryRoutes } from './syncV3LocalRecoveryRoutes.js';
+import { registerWorkspaceSyncV3LocalOwnershipRoutes } from './syncV3LocalOwnershipRoutes.js';
+import { registerWorkspaceSyncV3LocalFeedApplyRoutes } from './syncV3LocalFeedApplyRoutes.js';
+import { registerLocalSyncCoordinatorRoutes } from './syncCoordinatorLocalRoutes.js';
+import { registerWorkspaceSyncV3FeedRoutes } from './syncV3FeedRoutes.js';
+import { registerWorkspaceSyncV3DiagnosticsRoutes } from './syncV3DiagnosticsRoutes.js';
+import { isWorkspaceSyncV3InitiativeLegacyPushDisabled } from '../../sync/v3/planningActivation.js';
+import { partitionWorkspaceSyncV2LegacyChanges, } from '../../sync/v3/workspaceSyncV2ProjectionExclusions.js';
+import { resolveWorkspaceSyncV3AttestedV2Exclusions } from '../../sync/v3/workspaceSyncV3LegacyBoundaryAttestation.js';
+import { createWorkspaceSyncServerDataServices, } from '../../sync/engine/workspaceSyncServerDataServices.js';
 function decodeWorkspaceSyncCursor(raw) {
     const value = String(raw || '').trim();
     if (!value)
@@ -76,124 +83,19 @@ function normalizeIncomingAiProfileSeatScope(value, context) {
     }
     return normalized;
 }
-function normalizeTaskEventSyncPayload(raw, workspaceId, sourceWatermark) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
-        return null;
-    const source = raw;
-    const id = String(source.id || '').trim();
-    const entityType = source.entityType === 'initiative' || source.entityType === 'workstream'
-        ? source.entityType
-        : source.entity_type === 'initiative' || source.entity_type === 'workstream'
-            ? source.entity_type
-            : 'task';
-    const taskId = String(source.taskId || source.task_id || '').trim();
-    const entityId = String(source.entityId || source.entity_id || taskId).trim();
-    const action = String(source.action || '').trim();
-    const actor = String(source.actor || 'system').trim() || 'system';
-    const createdAt = String(source.createdAt || source.created_at || sourceWatermark || '').trim();
-    if (!id || !entityId || !action || !Number.isFinite(Date.parse(createdAt)))
-        return null;
-    const actorType = source.actorType === 'ai' || source.actorType === 'human' || source.actorType === 'system'
-        ? source.actorType
-        : source.actor_type === 'ai' || source.actor_type === 'human' || source.actor_type === 'system'
-            ? source.actor_type
-            : actor.startsWith('ai-profile-')
-                ? 'ai'
-                : actor === 'system'
-                    ? 'system'
-                    : 'human';
-    const details = source.details && typeof source.details === 'object' && !Array.isArray(source.details)
-        ? source.details
-        : {};
-    return {
-        id,
-        workspaceId,
-        entityType,
-        entityId,
-        taskId: entityType === 'task' ? (taskId || entityId) : undefined,
-        action,
-        actor,
-        actorType,
-        details,
-        createdAt
-    };
-}
 export function registerSyncRoutes(deps) {
     const { addRoute, core, context, auditAuthAction, resolveErrorStatusCode, requestWorkspaceId, resolveRequestAccess, isReservedWorkspaceId, createSessionTokenCookie } = deps;
-    const readPushIdempotency = (workspaceId, key) => {
-        return core.readPushIdempotency(workspaceId, key);
+    const claimPushIdempotency = (workspaceId, key, claimToken) => {
+        return core.claimPushIdempotency(workspaceId, key, claimToken);
     };
-    const workspaceAssetStore = typeof core.getDatabaseAdapter === 'function' && typeof core.getTenantId === 'function'
-        ? new WorkspaceAssetStore(core.getDatabaseAdapter(), core.getTenantId())
-        : null;
-    const resolveEffectiveObjectStorageConfig = () => {
-        const base = context.objectStorage || { provider: 'local' };
-        return base;
+    const releasePushIdempotencyClaim = (workspaceId, key, claimToken) => {
+        core.releasePushIdempotencyClaim(workspaceId, key, claimToken);
     };
-    const getObjectStorageClient = () => {
-        const resolved = resolveEffectiveObjectStorageConfig();
-        return resolved.provider === 'r2' ? new ObjectStorageClient(resolved) : null;
+    const renewPushIdempotencyClaim = (workspaceId, key, claimToken) => {
+        return core.renewPushIdempotencyClaim(workspaceId, key, claimToken);
     };
-    const writePushIdempotency = (workspaceId, key, payload) => {
-        core.writePushIdempotency(workspaceId, key, payload);
-    };
-    const recordSyncDiagnostic = (workspaceId, eventType, errorMessage, details) => {
-        try {
-            core.recordSyncEvent(workspaceId, {
-                eventType,
-                status: 'error',
-                errorMessage,
-                requestMs: 0,
-                details
-            });
-        }
-        catch {
-            // diagnostics must never throw
-        }
-        if (details && Object.keys(details).length > 0) {
-            // eslint-disable-next-line no-console
-            console.warn('[Taskforce Sync Diagnostic]', { workspaceId, eventType, errorMessage, ...details });
-        }
-    };
-    const validateTaskActorAssignments = (workspaceId, tasks, archived) => {
-        const entries = [...tasks, ...archived];
-        if (entries.length === 0)
-            return;
-        for (const task of entries) {
-            const assignee = String(task.assignee || '').trim();
-            if (!assignee || assignee === 'unassigned')
-                continue;
-            const actor = core.resolveWorkspaceActor(workspaceId, assignee);
-            if (actor && actor.meta?.unresolved !== true)
-                continue;
-            const unresolvedKind = actor?.kind === 'ai' ? 'ai' : 'human';
-            if (unresolvedKind === 'human')
-                continue;
-            throw createSyncRouteError(`Task ${String(task.id || '').trim() || '(unknown task)'} references unresolved assignee ${assignee}.`, {
-                source: 'apply.assigneeValidation',
-                workspaceId,
-                taskId: String(task.id || '').trim() || null,
-                assignee
-            }, { code: 'TASK_ACTOR_RESOLUTION_FAILED', statusCode: 400 });
-        }
-    };
-    const assertSyncedAiProfilesPersisted = (workspaceId, incomingAiProfiles) => {
-        if (incomingAiProfiles.size === 0)
-            return;
-        const persistedIds = new Set(core.listAiProfiles(workspaceId, { includeArchived: true })
-            .map((profile) => String(profile.id || '').trim())
-            .filter(Boolean));
-        for (const profile of incomingAiProfiles.values()) {
-            if (persistedIds.has(profile.id))
-                continue;
-            throw createSyncRouteError(`AI profile ${profile.id} was not persisted during sync apply.`, {
-                source: 'apply.aiProfileIntegrityCheck',
-                workspaceId,
-                profileId: profile.id,
-                expectedAiProfileCount: incomingAiProfiles.size,
-                persistedAiProfileCount: persistedIds.size
-            }, { code: 'AI_PROFILE_SYNC_APPLY_FAILED', statusCode: 500 });
-        }
+    const completePushIdempotencyClaim = (workspaceId, key, claimToken, payload) => {
+        return core.completePushIdempotencyClaim(workspaceId, key, claimToken, payload);
     };
     const normalizeWorkspaceMemberSyncSnapshot = (workspaceId, raw) => {
         const userId = String(raw?.userId || '').trim();
@@ -215,151 +117,13 @@ export function registerSyncRoutes(deps) {
             emailVerifiedAt: typeof raw?.emailVerifiedAt === 'string' ? raw.emailVerifiedAt.trim() || null : null
         };
     };
-    const workspaceDocumentSnapshotCache = new Map();
-    const workspaceTaxonomySyncMeta = new Map();
-    const isMarkdownPath = (relativePath) => {
-        const lower = relativePath.toLowerCase();
-        return lower.endsWith('.md') || lower.endsWith('.markdown');
-    };
-    const normalizeWorkspaceSyncDocumentPath = (rawPath) => {
-        const value = String(rawPath || '').trim().replace(/\\/g, '/');
-        if (!value || value.includes('\0'))
-            return null;
-        if (value.startsWith('/'))
-            return null;
-        const normalized = path.posix.normalize(value);
-        if (!normalized || normalized.startsWith('../') || normalized.includes('/../') || normalized === '..')
-            return null;
-        if (!isMarkdownPath(normalized))
-            return null;
-        if (/^workspaces\/[^/]+\/assets\/documents\//.test(normalized))
-            return normalized;
-        if (normalized.startsWith('docs/'))
-            return normalized;
-        return null;
-    };
-    const contentSyncState = createContentSyncState({
-        core,
-        workspaceAssetStore,
-        getObjectStorageClient,
-        normalizeWorkspaceSyncDocumentPath,
-        normalizeTaskDataRelativePath: (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim()),
-        recordSyncDiagnostic,
-        workspaceDocumentSnapshotCache,
-    });
-    const collaborationSyncState = createCollaborationSyncState({ core });
-    const dispatchWorkspaceSyncChanges = async (workspaceId, incomingChanges, options) => {
-        const emittedEventIds = new Set();
-        const unsubscribeRealtime = core.onRealtimeMutation((event) => {
-            const eventWorkspaceId = String(event?.workspaceId || '').trim();
-            if (eventWorkspaceId !== workspaceId)
-                return;
-            const eventId = String(event?.eventId || '').trim();
-            if (eventId)
-                emittedEventIds.add(eventId);
+    const serverDataServices = deps.serverDataServices
+        || createWorkspaceSyncServerDataServices({
+            core,
+            resolveObjectStorageConfig: () => context.objectStorage || { provider: 'local' },
+            now: () => new Date(),
         });
-        try {
-            const applyModel = classifyWorkspaceSyncChanges({
-                workspaceId,
-                incomingChanges,
-                normalizeWorkspaceSyncDocumentPath,
-                normalizeTaskAssetPath: (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim()),
-                normalizeIncomingAiProfileSurfaceType,
-                normalizeIncomingAiProfileSeatScope,
-                normalizeTaskEventSyncPayload,
-                recordSyncDiagnostic,
-            });
-            applyPlanningSyncChanges({
-                core,
-                workspaceId,
-                incomingInitiatives: applyModel.planning.incomingInitiatives,
-                incomingWorkstreams: applyModel.planning.incomingWorkstreams,
-                incomingTaxonomies: applyModel.planning.incomingTaxonomies,
-                incomingTaxonomyState: applyModel.planning.incomingTaxonomyState,
-                incomingTaxonomiesUpdatedAt: applyModel.planning.incomingTaxonomiesUpdatedAt,
-                workspaceTaxonomySyncMeta,
-                recordSyncDiagnostic,
-            });
-            applyAiProfileAndMemberSyncChanges({
-                core,
-                workspaceId,
-                incomingAiProfiles: applyModel.profiles.incomingAiProfiles,
-                workspaceMembers: options?.workspaceMembers,
-                recordSyncDiagnostic,
-                assertSyncedAiProfilesPersisted,
-                createSyncRouteError,
-            });
-            const preparedTaskSnapshot = prepareTaskSyncSnapshotApply({
-                core,
-                workspaceId,
-                taskMutations: applyModel.taskMutations,
-                recordSyncDiagnostic,
-            });
-            validateTaskActorAssignments(workspaceId, preparedTaskSnapshot.tasks, preparedTaskSnapshot.archived);
-            await applyContentSyncChanges({
-                core,
-                workspaceId,
-                incomingDocuments: applyModel.content.incomingDocuments,
-                incomingDocumentDeletes: applyModel.content.incomingDocumentDeletes,
-                incomingAssets: applyModel.content.incomingAssets,
-                incomingAssetDeletes: applyModel.content.incomingAssetDeletes,
-                basePath: core.getPaths().basePath,
-                hasObjectStorageClient: () => Boolean(getObjectStorageClient()),
-                hasDocumentSyncMetadataDrift: contentSyncState.hasDocumentSyncMetadataDrift,
-                hasBinaryAssetSyncMetadataDrift: contentSyncState.hasBinaryAssetSyncMetadataDrift,
-                getExistingDocument: (docPath, targetWorkspaceId) => {
-                    const asset = workspaceAssetStore?.getByStorageKey(docPath, targetWorkspaceId) || null;
-                    return asset
-                        ? {
-                            updatedAt: asset.updatedAt,
-                            contentHash: asset.contentSha256
-                        }
-                        : null;
-                },
-                writeWorkspaceSyncDocument: contentSyncState.writeWorkspaceSyncDocument,
-                deleteWorkspaceSyncDocument: contentSyncState.deleteWorkspaceSyncDocument,
-                writeWorkspaceSyncBinaryAsset: contentSyncState.writeWorkspaceSyncBinaryAsset,
-                deleteWorkspaceSyncBinaryAsset: contentSyncState.deleteWorkspaceSyncBinaryAsset,
-                getExistingBinaryAsset: (assetPath, targetWorkspaceId) => workspaceAssetStore?.getByStorageKey(assetPath, targetWorkspaceId) || null,
-                recordSyncDiagnostic,
-                options,
-            });
-            applyCollaborationSyncChanges({
-                core,
-                workspaceId,
-                incomingDocumentReviewSessions: applyModel.collaboration.incomingDocumentReviewSessions,
-                incomingDocumentReviewSessionDeletes: applyModel.collaboration.incomingDocumentReviewSessionDeletes,
-                incomingDocumentReviewComments: applyModel.collaboration.incomingDocumentReviewComments,
-                incomingDocumentReviewCommentDeletes: applyModel.collaboration.incomingDocumentReviewCommentDeletes,
-                incomingAnnotatedAttachmentSessions: applyModel.collaboration.incomingAnnotatedAttachmentSessions,
-                incomingAnnotatedAttachmentSessionDeletes: applyModel.collaboration.incomingAnnotatedAttachmentSessionDeletes,
-                recordSyncDiagnostic,
-                createSyncRouteError,
-            });
-            const deleteCount = applyTaskSyncDeletes({
-                core,
-                workspaceId,
-                taskMutations: applyModel.taskMutations,
-                recordSyncDiagnostic,
-            });
-            const result = applyPreparedTaskSyncSnapshot({
-                core,
-                workspaceId,
-                prepared: preparedTaskSnapshot,
-            });
-            applyTaskActivitySyncChanges({
-                core,
-                workspaceId,
-                incomingTaskEvents: applyModel.taskActivity.incomingTaskEvents,
-                recordSyncDiagnostic,
-                createSyncRouteError,
-            });
-            return { result, deleteCount, emittedEventIds: Array.from(emittedEventIds) };
-        }
-        finally {
-            unsubscribeRealtime();
-        }
-    };
+    const { workspaceAssetStore, publishedContentResolver, contentSyncState, collaborationSyncState, dispatchWorkspaceSyncChanges, dispatchWorkspaceSyncMetadataAtomically, prepareWorkspaceSyncV2Content, dispatchWorkspaceSyncPreparedContentAtomically, } = serverDataServices;
     // GET /api/taskforce/sync/user-settings - Pull user-global sync payload for authenticated user
     addRoute('GET', '/api/taskforce/sync/user-settings', async (req, res) => {
         const authConfig = context.authConfig;
@@ -607,7 +371,31 @@ export function registerSyncRoutes(deps) {
         }
         const tasks = Array.isArray(body?.tasks) ? body.tasks : [];
         const archived = Array.isArray(body?.archived) ? body.archived : [];
+        const incomingTaskIds = new Set([...tasks, ...archived]
+            .map((task) => String(task?.id || '').trim())
+            .filter((taskId) => taskId.length > 0));
+        const assertedActiveV3TaskMetadataIds = new Set((Array.isArray(body?.activeV3TaskMetadataIds) ? body.activeV3TaskMetadataIds : [])
+            .map((taskId) => String(taskId || '').trim())
+            .filter((taskId) => taskId.length > 0 && incomingTaskIds.has(taskId))
+            .slice(0, incomingTaskIds.size));
+        const assertedActiveV3TaskLifecycleIds = new Set((Array.isArray(body?.activeV3TaskLifecycleIds) ? body.activeV3TaskLifecycleIds : [])
+            .map((taskId) => String(taskId || '').trim())
+            .filter((taskId) => taskId.length > 0 && incomingTaskIds.has(taskId))
+            .slice(0, incomingTaskIds.size));
+        const assertedActiveV3TaskReopenAssigneeIds = new Set((Array.isArray(body?.activeV3TaskReopenAssigneeIds) ? body.activeV3TaskReopenAssigneeIds : [])
+            .map((taskId) => String(taskId || '').trim())
+            .filter((taskId) => taskId.length > 0 && incomingTaskIds.has(taskId))
+            .slice(0, incomingTaskIds.size));
         const incomingInitiatives = Array.isArray(body?.initiatives) ? body.initiatives : [];
+        const incomingInitiativeIdSet = new Set(incomingInitiatives
+            .map((initiative) => String(initiative?.id || '').trim())
+            .filter(Boolean));
+        const assertedActiveV3InitiativeIds = new Set((body?.v3InitiativeProjectionOwned === true
+            ? Array.from(incomingInitiativeIdSet)
+            : (Array.isArray(body?.activeV3InitiativeIds) ? body.activeV3InitiativeIds : []))
+            .map((initiativeId) => String(initiativeId || '').trim())
+            .filter((initiativeId) => initiativeId.length > 0 && incomingInitiativeIdSet.has(initiativeId))
+            .slice(0, incomingInitiativeIdSet.size));
         const incomingWorkstreams = Array.isArray(body?.workstreams) ? body.workstreams : [];
         const incomingTaxonomies = Array.isArray(body?.taxonomies) ? body.taxonomies : null;
         const incomingTaxonomyState = body?.taxonomyState && typeof body.taxonomyState === 'object' && !Array.isArray(body.taxonomyState)
@@ -618,7 +406,21 @@ export function registerSyncRoutes(deps) {
         const incomingDocumentReviewSessions = Array.isArray(body?.documentReviewSessions) ? body.documentReviewSessions : [];
         const incomingDocumentReviewComments = Array.isArray(body?.documentReviewComments) ? body.documentReviewComments : [];
         const incomingAnnotatedAttachmentSessions = Array.isArray(body?.annotatedAttachmentSessions) ? body.annotatedAttachmentSessions : [];
+        const incomingTaskforceAgents = Array.isArray(body?.taskforceAgents) ? body.taskforceAgents : [];
+        const incomingAgentRoles = Array.isArray(body?.agentRoles) ? body.agentRoles : [];
+        const incomingTaskforceAgentSkills = Array.isArray(body?.taskforceAgentSkills) ? body.taskforceAgentSkills : [];
+        const incomingAgentConversations = Array.isArray(body?.agentConversations) ? body.agentConversations : [];
         const incomingAssets = Array.isArray(body?.assets) ? body.assets : [];
+        const v2ExcludedProjections = resolveWorkspaceSyncV3AttestedV2Exclusions({
+            coverage: body?.combinedCoverage,
+            excludedProjections: body?.excludedProjections,
+        });
+        if (!v2ExcludedProjections) {
+            throw Object.assign(new Error('Workspace sync v2 projection boundary attestation is invalid.'), {
+                code: 'SYNC_V2_PROJECTION_BOUNDARY_MISMATCH', statusCode: 409,
+            });
+        }
+        let suppressedV2ProjectionCounts = {};
         try {
             const bootstrapChanges = [
                 ...((incomingTaxonomyState || incomingTaxonomies)
@@ -708,14 +510,58 @@ export function registerSyncRoutes(deps) {
                     op: 'annotated-attachment-session-upsert',
                     session
                 })),
+                ...incomingTaskforceAgents
+                    .map((agent) => normalizeTaskforceAgentSyncPayload(agent, cloudWorkspaceId))
+                    .filter((agent) => Boolean(agent && agent.id.length > 0 && agent.workspaceId.length > 0))
+                    .map((agent) => ({
+                    op: 'taskforce-agent-upsert',
+                    agent
+                })),
+                ...incomingAgentRoles
+                    .map((role) => normalizeAgentRoleSyncPayload(role, cloudWorkspaceId))
+                    .filter((role) => Boolean(role && role.id.length > 0 && role.workspaceId.length > 0))
+                    .map((role) => ({
+                    op: 'agent-role-upsert',
+                    role
+                })),
+                ...incomingTaskforceAgentSkills
+                    .map((skill) => normalizeTaskforceAgentSkillSyncPayload(skill, cloudWorkspaceId))
+                    .filter((skill) => Boolean(skill && skill.id.length > 0 && skill.workspaceId.length > 0))
+                    .map((skill) => ({
+                    op: 'taskforce-agent-skill-upsert',
+                    skill
+                })),
+                ...incomingAgentConversations
+                    .map((conversation) => normalizeAgentConversationSyncPayload(conversation, cloudWorkspaceId))
+                    .filter((conversation) => Boolean(conversation && conversation.id.length > 0 && conversation.workspaceId.length > 0 && conversation.agentId.length > 0))
+                    .map((conversation) => ({
+                    op: 'agent-conversation-upsert',
+                    conversation
+                })),
                 ...tasks.map((task) => ({ op: 'upsert', archived: false, task })),
                 ...archived.map((task) => ({ op: 'upsert', archived: true, task }))
             ];
-            const { result } = await dispatchWorkspaceSyncChanges(cloudWorkspaceId, bootstrapChanges);
+            const fenced = partitionWorkspaceSyncV2LegacyChanges(bootstrapChanges, new Set(v2ExcludedProjections));
+            suppressedV2ProjectionCounts = fenced.suppressedCounts;
+            if (fenced.changes.some((change) => change.op === 'initiative-upsert')
+                && isWorkspaceSyncV3InitiativeLegacyPushDisabled()) {
+                throw Object.assign(new Error('Legacy v2 initiative bootstrap is disabled while the v3 initiative feed owns synchronization.'), {
+                    code: 'WORKSPACE_SYNC_V3_INITIATIVE_LEGACY_PUSH_DISABLED', statusCode: 409,
+                });
+            }
+            const { result } = await dispatchWorkspaceSyncChanges(cloudWorkspaceId, fenced.changes, {
+                coexistenceDirection: 'cloud-push',
+                assertedActiveV3TaskMetadataIds,
+                assertedActiveV3TaskLifecycleIds,
+                assertedActiveV3TaskReopenAssigneeIds,
+                assertedActiveV3InitiativeIds,
+                v2ExcludedProjections,
+            });
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 success: true,
                 workspaceId: cloudWorkspaceId,
+                suppressedV2ProjectionCounts,
                 result
             }));
             auditAuthAction(req, 'sync-workspace-bootstrap-success', {
@@ -728,7 +574,10 @@ export function registerSyncRoutes(deps) {
                 documentReviewSessionCount: incomingDocumentReviewSessions.length,
                 documentReviewCommentCount: incomingDocumentReviewComments.length,
                 annotatedAttachmentSessionCount: incomingAnnotatedAttachmentSessions.length,
-                assetCount: incomingAssets.length
+                taskforceAgentCount: incomingTaskforceAgents.length,
+                agentConversationCount: incomingAgentConversations.length,
+                assetCount: incomingAssets.length,
+                suppressedV2ProjectionCounts,
             });
         }
         catch (error) {
@@ -737,14 +586,16 @@ export function registerSyncRoutes(deps) {
                 workspaceId: cloudWorkspaceId,
                 code: error?.code || null,
                 statusCode,
-                details: error?.details || null
+                details: error?.details || null,
+                suppressedV2ProjectionCounts,
             });
             res.writeHead(statusCode, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 success: false,
                 error: String(error?.message || 'Failed to apply workspace snapshot'),
                 code: error?.code,
-                details: error?.details || undefined
+                details: error?.details || undefined,
+                suppressedV2ProjectionCounts,
             }));
         }
     });
@@ -770,7 +621,10 @@ export function registerSyncRoutes(deps) {
         decodeWorkspaceSyncCursor,
         encodeWorkspaceSyncCursor,
         normalizeWorkspaceMemberSyncSnapshot,
-        dispatchWorkspaceSyncChanges
+        dispatchWorkspaceSyncChanges,
+        dispatchWorkspaceSyncMetadataAtomically,
+        prepareWorkspaceSyncV2Content,
+        dispatchWorkspaceSyncPreparedContentAtomically,
     });
     registerWorkspacePushSyncRoutes({
         addRoute,
@@ -779,8 +633,10 @@ export function registerSyncRoutes(deps) {
         auditAuthAction,
         resolveErrorStatusCode,
         resolveRequestAccess,
-        readPushIdempotency,
-        writePushIdempotency,
+        claimPushIdempotency,
+        completePushIdempotencyClaim,
+        releasePushIdempotencyClaim,
+        renewPushIdempotencyClaim,
         dispatchWorkspaceSyncChanges
     });
     registerWorkspaceSyncAuxRoutes({
@@ -789,6 +645,62 @@ export function registerSyncRoutes(deps) {
         context,
         resolveRequestAccess,
         requestWorkspaceId,
-        workspaceAssetStore
+        workspaceAssetStore,
+        publishedContentResolver
+    });
+    registerWorkspaceSyncV3OperationRoutes({
+        addRoute,
+        core,
+        context,
+        resolveRequestAccess,
+        auditAuthAction,
+    });
+    registerWorkspaceSyncV3FeedRoutes({
+        addRoute,
+        core,
+        context,
+        resolveRequestAccess,
+        auditAuthAction,
+    });
+    registerWorkspaceSyncV3DiagnosticsRoutes({
+        addRoute,
+        core,
+        context,
+        resolveRequestAccess,
+        auditAuthAction,
+        requestWorkspaceId,
+    });
+    registerWorkspaceSyncV3LocalCaptureRoutes({
+        addRoute,
+        core,
+        context,
+        requestWorkspaceId,
+    });
+    registerWorkspaceSyncV3LocalDispatchRoutes({
+        addRoute,
+        core,
+        context,
+        requestWorkspaceId,
+    });
+    registerWorkspaceSyncV3LocalRecoveryRoutes({
+        addRoute,
+        core,
+        context,
+        requestWorkspaceId,
+    });
+    registerWorkspaceSyncV3LocalOwnershipRoutes({
+        addRoute,
+        core,
+        context,
+    });
+    registerWorkspaceSyncV3LocalFeedApplyRoutes({
+        addRoute,
+        core,
+        context,
+    });
+    registerLocalSyncCoordinatorRoutes({
+        addRoute,
+        core,
+        services: context.localSyncCoordinator,
     });
 }

package/dist/server/routes/syncAuxRoutes.d.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage } from 'http';
+import type { WorkspaceSyncPublishedContentResolver } from '../../sync/engine/workspaceSyncPublishedContentResolver.js';
 import type { WorkspaceAssetStore } from '../../storage/workspaceAssetStore.js';
 import type { SyncAddRoute, SyncResolveRequestAccess, SyncRouteAuthConfig, SyncRouteCore } from './syncRouteTypes.js';
 interface RegisterWorkspaceSyncAuxRoutesArgs {
@@ -10,6 +11,7 @@ interface RegisterWorkspaceSyncAuxRoutesArgs {
     resolveRequestAccess: SyncResolveRequestAccess;
     requestWorkspaceId: (req: IncomingMessage) => string | null | undefined;
     workspaceAssetStore: WorkspaceAssetStore | null;
+    publishedContentResolver: Pick<WorkspaceSyncPublishedContentResolver, 'resolve'>;
 }
-export declare function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolveRequestAccess, requestWorkspaceId, workspaceAssetStore }: RegisterWorkspaceSyncAuxRoutesArgs): void;
+export declare function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolveRequestAccess, requestWorkspaceId, workspaceAssetStore, publishedContentResolver }: RegisterWorkspaceSyncAuxRoutesArgs): void;
 export {};

package/dist/server/routes/syncAuxRoutes.js

@@ -2,7 +2,7 @@ import { applyWorkspaceRepair } from '../../sync/workspaceRepair.js';
 import { normalizeSyncEventDetails } from '../../utils/syncEventDetails.js';
 import { parseJsonBody } from './primitives.js';
 import { requireAuthenticatedSyncRequest } from './syncRouteGuards.js';
-export function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolveRequestAccess, requestWorkspaceId, workspaceAssetStore }) {
+export function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolveRequestAccess, requestWorkspaceId, workspaceAssetStore, publishedContentResolver }) {
     // GET /api/taskforce/sync/events - Query recent sync events (local runtime only)
     addRoute('GET', '/api/taskforce/sync/events', async (req, res) => {
         const authConfig = context.authConfig;
@@ -49,9 +49,9 @@ export function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolv
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ success: true }));
     });
-    // POST /api/taskforce/sync/workspace/repair-startup - Auto-repair missing asset/document
-    // metadata on workspace open. Only safe fixups: re-registers DB records for files that
-    // exist on disk but have no (or a stale deleted) metadata entry. Never deletes files.
+    // POST /api/taskforce/sync/workspace/repair-startup - Auto-repair workspace asset/document
+    // metadata on workspace open. Safe fixups re-register metadata for local files and mark
+    // stale, unreferenced metadata deleted when the file is missing. Never deletes files.
     // Called once by the sync orchestrator when the workspace becomes active.
     addRoute('POST', '/api/taskforce/sync/workspace/repair-startup', async (req, res) => {
         const authConfig = context.authConfig;
@@ -72,12 +72,17 @@ export function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolv
         }
         const { basePath } = core.getPaths();
         const result = applyWorkspaceRepair({
+            tenantId: core.getTenantId(),
             workspaceId,
             basePath,
             tasks: core.listTasks(workspaceId)?.tasks || [],
             archivedTasks: core.listArchive(workspaceId)?.archived || [],
             deletedTasks: core.listWorkspaceSyncDeletes(workspaceId) || [],
             workspaceAssetStore,
+            publishedContentResolver,
+            aiProfiles: typeof core.listAiProfiles === 'function'
+                ? core.listAiProfiles(workspaceId, { includeArchived: true }) || []
+                : [],
             upsertDocumentWatermark: (targetWorkspaceId, docPath, contentHash, updatedAt) => {
                 core.upsertDocumentWatermark(targetWorkspaceId, docPath, contentHash, updatedAt);
             }

package/dist/server/routes/syncCoordinatorLocalRoutes.d.ts

@@ -0,0 +1,6 @@
+import type { SyncAddRoute, SyncRouteCore } from './syncRouteTypes.js';
+export declare function registerLocalSyncCoordinatorRoutes(input: {
+    addRoute: SyncAddRoute;
+    core: SyncRouteCore;
+    services?: import('../../sync/coordinator/localSyncCoordinatorRouteServices.js').LocalSyncCoordinatorRouteServices | null;
+}): void;