@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/server/routes/syncV3LocalCaptureRoutes.js

@@ -0,0 +1,915 @@
+import { DurableTaskRelationshipMutationError } from '../../core/TaskDurableRelationshipMutationService.js';
+import { EntityEventIdentityCollisionError } from '../../core/TaskActivityService.js';
+import { DurableTaskMetadataMutationError } from '../../core/TaskDurableSyncMutationService.js';
+import { DurableTaskCreateMutationError } from '../../core/TaskDurableCreateMutationService.js';
+import { DurableTaskDeleteMutationError } from '../../core/TaskDurableDeleteMutationService.js';
+import { DurableTaskRestoreMutationError } from '../../core/TaskDurableRestoreMutationService.js';
+import { parseTaskRestoreDestination, } from '../../shared/taskRestoreDestination.js';
+import { DurableTaskLifecycleMutationError } from '../../core/TaskDurableLifecycleMutationService.js';
+import { DurableTaskWorkflowMutationError } from '../../core/TaskDurableWorkflowMutationService.js';
+import { DurableInitiativeApplyError } from '../../core/InitiativeDurableMutationService.js';
+import { DurableWorkstreamApplyError } from '../../core/WorkstreamDurableMutationService.js';
+import { DurableTaskStatusMutationError, validateDurableTaskStatusMutationPayload, } from '../../core/TaskDurableStatusMutationService.js';
+import { LocalSyncIdentityStore } from '../../sync/v3/localSyncIdentityStore.js';
+import { enqueueLocalTaskMetadataMutation } from '../../sync/v3/localTaskMetadataOutboxService.js';
+import { enqueueLocalTaskCreateMutation } from '../../sync/v3/localTaskCreateOutboxService.js';
+import { enqueueLocalTaskDeleteMutation } from '../../sync/v3/localTaskDeleteOutboxService.js';
+import { enqueueLocalTaskRestoreMutation } from '../../sync/v3/localTaskRestoreOutboxService.js';
+import { enqueueLocalTaskRelationshipMutation, LocalAuthoritativeTaskRelationshipError, } from '../../sync/v3/localTaskRelationshipOutboxService.js';
+import { enqueueLocalTaskLifecycleMutation } from '../../sync/v3/localTaskLifecycleOutboxService.js';
+import { enqueueLocalTaskStatusMutation } from '../../sync/v3/localTaskStatusOutboxService.js';
+import { enqueueLocalTaskCommentMutation } from '../../sync/v3/localTaskCommentOutboxService.js';
+import { LocalAuthoritativeTaskCommentError } from '../../sync/v3/localTaskCommentOutboxService.js';
+import { enqueueLocalTaskChecklistMutation, LocalAuthoritativeTaskChecklistError, } from '../../sync/v3/localTaskChecklistOutboxService.js';
+import { enqueueLocalTaskAttachmentLinksMutation, LocalAuthoritativeTaskAttachmentLinksError, } from '../../sync/v3/localTaskAttachmentLinksOutboxService.js';
+import { resolveTaskAttachmentLinksMutationCapability } from '../../sync/v3/durableTaskAttachmentLinksMutationRouter.js';
+import { validateWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3TaskChecklistPayload, validateWorkspaceSyncV3TaskCommentsPayload, } from '../../sync/v3/workspaceSyncV3NestedTaskCodecs.js';
+import { enqueueLocalTaxonomyReplacement } from '../../sync/v3/localTaxonomyOutboxService.js';
+import { enqueueLocalTaxonomyCompositeReplacement } from '../../sync/v3/localTaxonomyCompositeOutboxService.js';
+import { enqueueLocalInitiativeMutation } from '../../sync/v3/localInitiativeOutboxService.js';
+import { enqueueLocalWorkstreamMutation } from '../../sync/v3/localWorkstreamOutboxService.js';
+import { DurableInitiativeMutationError, validateDurableInitiativeComment, validateDurableInitiativeCreatePayload, validateDurableInitiativeMetadataPatch, validateEmptyInitiativePayload, } from '../../sync/v3/initiativeMutationPayload.js';
+import { DurableWorkstreamMutationError, validateDurableWorkstreamComment, validateDurableWorkstreamCreatePayload, validateDurableWorkstreamMetadataPatch, validateEmptyWorkstreamPayload, } from '../../sync/v3/workstreamMutationPayload.js';
+import { validateTaxonomyTaskRemapPatches } from '../../sync/v3/taxonomyCompositeMutationService.js';
+import { DurableTaxonomyMutationError, validateCanonicalTaxonomyState } from '../../sync/v3/taxonomySyncPayload.js';
+import { validateDurableTaskLifecyclePayload } from '../../sync/v3/taskLifecycleMutationService.js';
+import { validateDurableTaskWorkflowPayload } from '../../sync/v3/taskWorkflowMutationService.js';
+import { WorkspaceSyncDurabilityStore, WorkspaceSyncEntityBusyError, WorkspaceSyncIdempotencyConflictError, } from '../../sync/v3/syncDurabilityStore.js';
+import { WorkspaceSyncV3CombinedProjectionStateStore } from '../../sync/v3/workspaceSyncV3CombinedProjectionState.js';
+import { parseJsonBody } from './primitives.js';
+const ROUTE_PATH = '/api/taskforce/sync/v3/local/operations';
+const MAX_BODY_BYTES = 1024 * 1024;
+const MAX_ID_LENGTH = 200;
+class LocalCaptureRequestError extends Error {
+    code;
+    statusCode;
+    constructor(message, code = 'WORKSPACE_SYNC_LOCAL_REQUEST_INVALID', statusCode = 400) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'LocalCaptureRequestError';
+    }
+}
+function writeJson(res, statusCode, body) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+function requireRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new LocalCaptureRequestError(`${label} must be an object.`);
+    }
+    return value;
+}
+function assertExactKeys(value, keys, label) {
+    const expected = new Set(keys);
+    const actual = Object.keys(value);
+    if (actual.length !== keys.length || actual.some((key) => !expected.has(key))) {
+        throw new LocalCaptureRequestError(`${label} must contain exactly: ${keys.join(', ')}.`);
+    }
+}
+function requireId(value, label) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    if (!normalized || normalized.length > MAX_ID_LENGTH) {
+        throw new LocalCaptureRequestError(`${label} must be a non-empty string no longer than ${MAX_ID_LENGTH} characters.`);
+    }
+    return normalized;
+}
+function replayQuery(req) {
+    const url = new URL(req.url || ROUTE_PATH, 'http://localhost');
+    return {
+        workspaceId: requireId(url.searchParams.get('workspaceId'), 'workspaceId'),
+        operationId: requireId(url.searchParams.get('operationId'), 'operationId'),
+    };
+}
+function parseEnvelope(raw) {
+    const body = requireRecord(raw, 'request');
+    assertExactKeys(body, ['contractVersion', 'workspaceId', 'operationId', 'operation'], 'request');
+    if (body.contractVersion !== 3)
+        throw new LocalCaptureRequestError('contractVersion must be 3.');
+    const operation = requireRecord(body.operation, 'operation');
+    assertExactKeys(operation, ['domain', 'entityId', 'mutationKind', 'payload'], 'operation');
+    const payload = requireRecord(operation.payload, 'operation.payload');
+    const common = {
+        workspaceId: requireId(body.workspaceId, 'workspaceId'),
+        operationId: requireId(body.operationId, 'operationId'),
+        entityId: requireId(operation.entityId, 'operation.entityId'),
+    };
+    if (operation.domain === 'task' && operation.mutationKind === 'metadata-update') {
+        const saveSource = payload.saveSource;
+        assertExactKeys(payload, saveSource === undefined ? ['patch'] : ['patch', 'saveSource'], 'operation.payload');
+        if (saveSource !== undefined && saveSource !== 'manual' && saveSource !== 'autosave') {
+            throw new LocalCaptureRequestError('operation.payload.saveSource must be manual or autosave.');
+        }
+        return {
+            ...common,
+            domain: 'task',
+            mutationKind: 'metadata-update',
+            patch: requireRecord(payload.patch, 'operation.payload.patch'),
+            ...(saveSource ? { saveSource } : {}),
+        };
+    }
+    if (operation.domain === 'task' && operation.mutationKind === 'create') {
+        if (Object.keys(payload).length !== 1 || !Object.prototype.hasOwnProperty.call(payload, 'task')) {
+            assertExactKeys(payload, ['task', 'localCarriers'], 'operation.payload');
+        }
+        const localCarriers = payload.localCarriers === undefined
+            ? { attachments: [], checklistItems: [], comments: [] }
+            : requireRecord(payload.localCarriers, 'operation.payload.localCarriers');
+        if (payload.localCarriers !== undefined) {
+            assertExactKeys(localCarriers, ['attachments', 'checklistItems', 'comments'], 'operation.payload.localCarriers');
+        }
+        if (!Array.isArray(localCarriers.attachments)
+            || !Array.isArray(localCarriers.checklistItems)
+            || !Array.isArray(localCarriers.comments)) {
+            throw new LocalCaptureRequestError('Task create local carriers must be arrays.');
+        }
+        return {
+            ...common,
+            domain: 'task',
+            mutationKind: 'create',
+            task: requireRecord(payload.task, 'operation.payload.task'),
+            localCarriers: localCarriers,
+        };
+    }
+    if (operation.domain === 'task' && operation.mutationKind === 'delete') {
+        assertExactKeys(payload, [], 'operation.payload');
+        return { ...common, domain: 'task', mutationKind: 'delete', payload: {} };
+    }
+    if (operation.domain === 'task' && operation.mutationKind === 'restore') {
+        assertExactKeys(payload, Object.prototype.hasOwnProperty.call(payload, 'restoreDestination')
+            ? ['deletedRecordId', 'restoreDestination']
+            : ['deletedRecordId'], 'operation.payload');
+        const restoreDestination = parseTaskRestoreDestination(payload.restoreDestination);
+        if (!restoreDestination) {
+            throw new LocalCaptureRequestError('operation.payload.restoreDestination must be previous or archive.');
+        }
+        return {
+            ...common,
+            domain: 'task',
+            mutationKind: 'restore',
+            deletedRecordId: requireId(payload.deletedRecordId, 'operation.payload.deletedRecordId'),
+            restoreDestination,
+        };
+    }
+    if (operation.domain === 'task' && (operation.mutationKind === 'archive' || operation.mutationKind === 'unarchive')) {
+        const normalized = validateDurableTaskLifecyclePayload(operation.mutationKind, payload);
+        return {
+            ...common,
+            domain: 'task',
+            mutationKind: operation.mutationKind,
+            payload: operation.mutationKind === 'archive' ? normalized : {},
+        };
+    }
+    if (operation.domain === 'task' && (operation.mutationKind === 'complete' || operation.mutationKind === 'reopen')) {
+        const normalized = validateDurableTaskWorkflowPayload(operation.mutationKind, payload);
+        return {
+            ...common,
+            domain: 'task',
+            mutationKind: operation.mutationKind,
+            payload: operation.mutationKind === 'reopen' ? normalized : {},
+        };
+    }
+    if (operation.domain === 'task' && operation.mutationKind === 'set-status') {
+        return {
+            ...common,
+            domain: 'task',
+            mutationKind: 'set-status',
+            payload: validateDurableTaskStatusMutationPayload(payload),
+        };
+    }
+    if (operation.domain === 'task-comments' && operation.mutationKind === 'append') {
+        assertExactKeys(payload, ['comment'], 'operation.payload');
+        let comments;
+        try {
+            comments = validateWorkspaceSyncV3TaskCommentsPayload({
+                taskId: common.entityId,
+                comments: [requireRecord(payload.comment, 'operation.payload.comment')],
+            }).comments;
+        }
+        catch (error) {
+            throw new LocalCaptureRequestError(error instanceof Error ? error.message : 'operation.payload.comment is invalid.', 'WORKSPACE_SYNC_LOCAL_REQUEST_INVALID', 400);
+        }
+        return { ...common, domain: 'task-comments', mutationKind: 'append', comment: comments[0] };
+    }
+    if (operation.domain === 'task-checklist' && operation.mutationKind === 'replace') {
+        assertExactKeys(payload, ['items'], 'operation.payload');
+        let items;
+        try {
+            items = validateWorkspaceSyncV3TaskChecklistPayload({ taskId: common.entityId, items: payload.items }).items;
+        }
+        catch (error) {
+            throw new LocalCaptureRequestError(error instanceof Error ? error.message : 'operation.payload.items is invalid.');
+        }
+        return { ...common, domain: 'task-checklist', mutationKind: 'replace', items };
+    }
+    if (operation.domain === 'task-attachment-links' && operation.mutationKind === 'replace') {
+        const hasCardCoverAssetId = Object.prototype.hasOwnProperty.call(payload, 'cardCoverAssetId');
+        assertExactKeys(payload, hasCardCoverAssetId ? ['links', 'cardCoverAssetId'] : ['links'], 'operation.payload');
+        let links;
+        try {
+            links = validateWorkspaceSyncV3TaskAttachmentLinksPayload({ taskId: common.entityId, links: payload.links }).links;
+        }
+        catch (error) {
+            throw new LocalCaptureRequestError(error instanceof Error ? error.message : 'operation.payload.links is invalid.');
+        }
+        if (hasCardCoverAssetId && payload.cardCoverAssetId !== null
+            && (typeof payload.cardCoverAssetId !== 'string' || !payload.cardCoverAssetId.trim())) {
+            throw new LocalCaptureRequestError('operation.payload.cardCoverAssetId must be a non-empty string or null.');
+        }
+        return {
+            ...common,
+            domain: 'task-attachment-links',
+            mutationKind: 'replace',
+            links,
+            ...(hasCardCoverAssetId ? {
+                cardCoverAssetId: payload.cardCoverAssetId === null
+                    ? null
+                    : String(payload.cardCoverAssetId).trim(),
+            } : {}),
+        };
+    }
+    if (operation.domain === 'initiative') {
+        const base = {
+            domain: 'initiative',
+            entityId: common.entityId,
+            baseEntityRevision: '0',
+            baseLifecycleRevision: '0',
+        };
+        if (operation.mutationKind === 'create') {
+            return {
+                ...common, domain: 'initiative', mutationKind: 'create',
+                operation: { ...base, mutationKind: 'create', payload: validateDurableInitiativeCreatePayload(payload) },
+            };
+        }
+        if (operation.mutationKind === 'metadata-update') {
+            assertExactKeys(payload, ['patch'], 'operation.payload');
+            return {
+                ...common, domain: 'initiative', mutationKind: 'metadata-update',
+                operation: { ...base, mutationKind: 'metadata-update', payload: { patch: validateDurableInitiativeMetadataPatch(payload.patch) } },
+            };
+        }
+        if (operation.mutationKind === 'append-comment') {
+            assertExactKeys(payload, ['comment'], 'operation.payload');
+            return {
+                ...common, domain: 'initiative', mutationKind: 'append-comment',
+                operation: { ...base, mutationKind: 'append-comment', payload: { comment: validateDurableInitiativeComment(payload.comment) } },
+            };
+        }
+        if (operation.mutationKind === 'archive' || operation.mutationKind === 'unarchive') {
+            return {
+                ...common, domain: 'initiative', mutationKind: operation.mutationKind,
+                operation: {
+                    ...base, mutationKind: operation.mutationKind,
+                    payload: validateEmptyInitiativePayload(payload, `Initiative ${operation.mutationKind} payload`),
+                },
+            };
+        }
+    }
+    if (operation.domain === 'workstream') {
+        const base = {
+            domain: 'workstream',
+            entityId: common.entityId,
+            baseEntityRevision: '0',
+            baseLifecycleRevision: '0',
+        };
+        if (operation.mutationKind === 'create') {
+            return {
+                ...common, domain: 'workstream', mutationKind: 'create',
+                operation: { ...base, mutationKind: 'create', payload: validateDurableWorkstreamCreatePayload(payload) },
+            };
+        }
+        if (operation.mutationKind === 'metadata-update') {
+            assertExactKeys(payload, ['patch'], 'operation.payload');
+            return {
+                ...common, domain: 'workstream', mutationKind: 'metadata-update',
+                operation: { ...base, mutationKind: 'metadata-update', payload: { patch: validateDurableWorkstreamMetadataPatch(payload.patch) } },
+            };
+        }
+        if (operation.mutationKind === 'append-comment') {
+            assertExactKeys(payload, ['comment'], 'operation.payload');
+            return {
+                ...common, domain: 'workstream', mutationKind: 'append-comment',
+                operation: { ...base, mutationKind: 'append-comment', payload: { comment: validateDurableWorkstreamComment(payload.comment) } },
+            };
+        }
+        if (operation.mutationKind === 'archive' || operation.mutationKind === 'unarchive') {
+            return {
+                ...common, domain: 'workstream', mutationKind: operation.mutationKind,
+                operation: {
+                    ...base, mutationKind: operation.mutationKind,
+                    payload: validateEmptyWorkstreamPayload(payload, `Workstream ${operation.mutationKind} payload`),
+                },
+            };
+        }
+    }
+    if (operation.domain === 'task-relationship'
+        && (operation.mutationKind === 'link' || operation.mutationKind === 'unlink')) {
+        assertExactKeys(payload, ['sourceTaskId', 'targetTaskId', 'type'], 'operation.payload');
+        const type = String(payload.type || '');
+        if (!['depends_on', 'blocks', 'related_to', 'supersedes'].includes(type)) {
+            throw new LocalCaptureRequestError('operation.payload.type is invalid.');
+        }
+        return {
+            ...common,
+            domain: 'task-relationship',
+            mutationKind: operation.mutationKind,
+            sourceTaskId: requireId(payload.sourceTaskId, 'operation.payload.sourceTaskId'),
+            targetTaskId: requireId(payload.targetTaskId, 'operation.payload.targetTaskId'),
+            type,
+        };
+    }
+    if (operation.domain === 'taxonomy' && operation.mutationKind === 'replace-state-with-task-remaps') {
+        if (common.entityId !== '__taxonomy_config__') {
+            throw new LocalCaptureRequestError('Taxonomy entityId must be __taxonomy_config__.');
+        }
+        assertExactKeys(payload, ['state', 'taskPatches'], 'operation.payload');
+        const state = validateCanonicalTaxonomyState(payload.state);
+        if (!Array.isArray(payload.taskPatches)) {
+            throw new LocalCaptureRequestError('operation.payload.taskPatches must be an array.');
+        }
+        const taskPatches = payload.taskPatches.map((raw, index) => {
+            const entry = requireRecord(raw, `operation.payload.taskPatches[${index}]`);
+            assertExactKeys(entry, ['entityId', 'baseEntityRevision', 'baseLifecycleRevision', 'patch'], `operation.payload.taskPatches[${index}]`);
+            const baseEntityRevision = String(entry.baseEntityRevision ?? '').trim();
+            const baseLifecycleRevision = String(entry.baseLifecycleRevision ?? '').trim();
+            if (!/^\d+$/.test(baseEntityRevision) || !/^\d+$/.test(baseLifecycleRevision)) {
+                throw new LocalCaptureRequestError(`operation.payload.taskPatches[${index}] revisions are invalid.`);
+            }
+            return {
+                entityId: requireId(entry.entityId, `operation.payload.taskPatches[${index}].entityId`),
+                baseEntityRevision,
+                baseLifecycleRevision,
+                patch: requireRecord(entry.patch, `operation.payload.taskPatches[${index}].patch`),
+            };
+        });
+        return {
+            ...common,
+            domain: 'taxonomy',
+            mutationKind: 'replace-state-with-task-remaps',
+            taxonomyState: state,
+            taskPatches: validateTaxonomyTaskRemapPatches(taskPatches, state),
+        };
+    }
+    if (operation.domain === 'taxonomy' && operation.mutationKind === 'replace-state') {
+        if (common.entityId !== '__taxonomy_config__') {
+            throw new LocalCaptureRequestError('Taxonomy entityId must be __taxonomy_config__.');
+        }
+        assertExactKeys(payload, ['state'], 'operation.payload');
+        return {
+            ...common,
+            domain: 'taxonomy',
+            mutationKind: 'replace-state',
+            taxonomyState: validateCanonicalTaxonomyState(payload.state),
+        };
+    }
+    throw new LocalCaptureRequestError('The operation domain or kind is not supported.');
+}
+export function isWorkspaceSyncV3LocalCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_LOCAL_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskCreateCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_CREATE_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskRelationshipCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_RELATIONSHIP_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskDeleteCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_DELETE_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskLifecycleCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_LIFECYCLE_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskStatusCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_STATUS_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskCommentsCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_COMMENTS_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskChecklistCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_CHECKLIST_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaskAttachmentLinksCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TASK_ATTACHMENT_LINKS_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3TaxonomyCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_TAXONOMY_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3InitiativeCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_INITIATIVE_CAPTURE_ENABLED || '').trim());
+}
+export function isWorkspaceSyncV3WorkstreamCaptureEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_SYNC_V3_WORKSTREAM_CAPTURE_ENABLED || '').trim());
+}
+export function registerWorkspaceSyncV3LocalCaptureRoutes(input) {
+    const enabled = input.enabled ?? isWorkspaceSyncV3LocalCaptureEnabled();
+    const createEnabled = input.createEnabled ?? isWorkspaceSyncV3TaskCreateCaptureEnabled();
+    const deleteEnabled = input.deleteEnabled ?? isWorkspaceSyncV3TaskDeleteCaptureEnabled();
+    const relationshipEnabled = input.relationshipEnabled ?? isWorkspaceSyncV3TaskRelationshipCaptureEnabled();
+    const lifecycleEnabled = input.lifecycleEnabled ?? isWorkspaceSyncV3TaskLifecycleCaptureEnabled();
+    const statusEnabled = input.statusEnabled ?? isWorkspaceSyncV3TaskStatusCaptureEnabled();
+    const commentsEnabled = input.commentsEnabled ?? isWorkspaceSyncV3TaskCommentsCaptureEnabled();
+    const checklistEnabled = input.checklistEnabled ?? isWorkspaceSyncV3TaskChecklistCaptureEnabled();
+    const attachmentLinksEnabled = input.attachmentLinksEnabled ?? isWorkspaceSyncV3TaskAttachmentLinksCaptureEnabled();
+    const taxonomyEnabled = input.taxonomyEnabled ?? isWorkspaceSyncV3TaxonomyCaptureEnabled();
+    const initiativeEnabled = input.initiativeEnabled ?? isWorkspaceSyncV3InitiativeCaptureEnabled();
+    const workstreamEnabled = input.workstreamEnabled ?? isWorkspaceSyncV3WorkstreamCaptureEnabled();
+    const now = input.now || (() => new Date());
+    const resolveActiveWorkspaceId = input.resolveActiveWorkspaceId
+        || (() => input.core.resolvePreferredWorkspaceId({ allowDefault: true }));
+    // Replay lookup remains available after activation is disabled. A stale or
+    // suspended browser participant can prove its already-captured operation
+    // from SQLite without retaining task content in browser storage.
+    input.addRoute('GET', ROUTE_PATH, async (req, res) => {
+        if (input.context.authConfig?.runtimeMode === 'cloud') {
+            writeJson(res, 404, { success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_CAPTURE_DISABLED' });
+            return;
+        }
+        try {
+            const query = replayQuery(req);
+            const activeWorkspaceId = String(resolveActiveWorkspaceId() || '').trim();
+            if (!activeWorkspaceId || activeWorkspaceId !== query.workspaceId) {
+                throw new LocalCaptureRequestError('Request workspace does not match the operation workspace.', 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH', 409);
+            }
+            const db = input.core.getDatabaseAdapter();
+            const clientId = new LocalSyncIdentityStore(db).getClientId();
+            const operation = clientId
+                ? new WorkspaceSyncDurabilityStore(db).readOutboxOperation({
+                    tenantId: input.core.getTenantId(),
+                    workspaceId: query.workspaceId,
+                    clientId,
+                    operationId: query.operationId,
+                })
+                : null;
+            if (!operation || operation.domain !== 'task' || operation.mutationKind !== 'create') {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Operation not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_OPERATION_NOT_FOUND',
+                });
+                return;
+            }
+            const payload = requireRecord(JSON.parse(operation.payloadJson), 'stored operation payload');
+            if (Object.keys(payload).length !== 1 || !Object.prototype.hasOwnProperty.call(payload, 'task')) {
+                assertExactKeys(payload, ['task', 'localCarriers'], 'stored operation payload');
+            }
+            const taskInput = requireRecord(payload.task, 'stored operation payload.task');
+            const localCarriers = payload.localCarriers === undefined
+                ? { attachments: [], checklistItems: [], comments: [] }
+                : requireRecord(payload.localCarriers, 'stored operation payload.localCarriers');
+            const task = input.core.getTask(operation.entityId, query.workspaceId);
+            if (!task)
+                throw new LocalCaptureRequestError('Captured task not found.', 'TASK_NOT_FOUND', 404);
+            writeJson(res, 200, {
+                success: true,
+                contractVersion: 3,
+                workspaceId: query.workspaceId,
+                clientId,
+                operationId: query.operationId,
+                operation: {
+                    domain: 'task',
+                    entityId: operation.entityId,
+                    mutationKind: 'create',
+                    payload: { task: taskInput, localCarriers },
+                },
+                task,
+            });
+        }
+        catch (error) {
+            const known = error instanceof LocalCaptureRequestError ? error : null;
+            writeJson(res, known?.statusCode || 500, {
+                success: false,
+                error: known?.message || 'Failed to read local workspace sync operation.',
+                code: known?.code || 'WORKSPACE_SYNC_LOCAL_CAPTURE_INTERNAL_ERROR',
+            });
+        }
+    });
+    input.addRoute('POST', ROUTE_PATH, async (req, res) => {
+        if (input.context.authConfig?.runtimeMode === 'cloud') {
+            writeJson(res, 404, { success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_CAPTURE_DISABLED' });
+            return;
+        }
+        try {
+            const db = input.core.getDatabaseAdapter();
+            const store = new WorkspaceSyncDurabilityStore(db);
+            const identityStore = new LocalSyncIdentityStore(db);
+            const envelope = parseEnvelope(await parseJsonBody(req, MAX_BODY_BYTES));
+            const requestedWorkspaceId = input.requestWorkspaceId(req);
+            if (!requestedWorkspaceId || requestedWorkspaceId !== envelope.workspaceId) {
+                throw new LocalCaptureRequestError('Request workspace does not match the operation workspace.', 'WORKSPACE_SYNC_LOCAL_WORKSPACE_MISMATCH', 409);
+            }
+            const combinedProjectionOwned = new WorkspaceSyncV3CombinedProjectionStateStore(db).read({
+                tenantId: input.core.getTenantId(),
+                workspaceId: envelope.workspaceId,
+            }).owner === 'v3';
+            const taskLifecycleOperation = envelope.domain === 'task'
+                && ['archive', 'unarchive', 'complete', 'reopen'].includes(envelope.mutationKind);
+            const persistedLifecycleOwnershipRequiresCapture = taskLifecycleOperation && combinedProjectionOwned;
+            if (!enabled && !persistedLifecycleOwnershipRequiresCapture) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'task' && envelope.mutationKind === 'create' && !createEnabled) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_CREATE_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if ((envelope.mutationKind === 'delete' || envelope.mutationKind === 'restore') && !deleteEnabled) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_DELETE_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'task-relationship' && !relationshipEnabled) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_RELATIONSHIP_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (taskLifecycleOperation
+                && !lifecycleEnabled
+                && !combinedProjectionOwned) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_LIFECYCLE_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'task' && envelope.mutationKind === 'set-status' && !statusEnabled) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_STATUS_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'task-comments' && !commentsEnabled) {
+                writeJson(res, 404, {
+                    success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_TASK_COMMENTS_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'task-checklist' && !checklistEnabled) {
+                writeJson(res, 404, {
+                    success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_TASK_CHECKLIST_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'task-attachment-links' && !attachmentLinksEnabled) {
+                writeJson(res, 404, {
+                    success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_TASK_ATTACHMENT_LINKS_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'taxonomy' && !taxonomyEnabled) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Not found.',
+                    code: 'WORKSPACE_SYNC_LOCAL_TAXONOMY_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'initiative' && !initiativeEnabled) {
+                writeJson(res, 404, {
+                    success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_INITIATIVE_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'workstream' && !workstreamEnabled) {
+                writeJson(res, 404, {
+                    success: false, error: 'Not found.', code: 'WORKSPACE_SYNC_LOCAL_WORKSTREAM_CAPTURE_DISABLED',
+                });
+                return;
+            }
+            if (envelope.domain === 'task-relationship') {
+                const canonical = input.core.resolveTaskRelationshipIdentity(envelope.sourceTaskId, envelope.targetTaskId, envelope.type, envelope.workspaceId);
+                if (canonical.id !== envelope.entityId) {
+                    throw new LocalCaptureRequestError('Task relationship identity is not canonical.', 'WORKSPACE_SYNC_LOCAL_RELATIONSHIP_IDENTITY_INVALID', 409);
+                }
+            }
+            const acceptedAt = now().toISOString();
+            const clientId = identityStore.getOrCreateClientId(acceptedAt);
+            const identity = {
+                tenantId: input.core.getTenantId(),
+                workspaceId: envelope.workspaceId,
+                clientId,
+                operationId: envelope.operationId,
+            };
+            const localAuthorizationActor = 'user';
+            const result = envelope.domain === 'workstream'
+                ? enqueueLocalWorkstreamMutation({
+                    store,
+                    core: input.core,
+                    identity,
+                    operation: envelope.operation.mutationKind === 'append-comment'
+                        ? {
+                            ...envelope.operation,
+                            payload: {
+                                comment: {
+                                    ...envelope.operation.payload.comment,
+                                    author: localAuthorizationActor,
+                                    submittedAuthor: localAuthorizationActor,
+                                },
+                            },
+                        }
+                        : envelope.operation,
+                    now: acceptedAt,
+                    actorRef: localAuthorizationActor,
+                    onPostCommitError: input.onPostCommitError,
+                })
+                : envelope.domain === 'initiative'
+                    ? enqueueLocalInitiativeMutation({
+                        store,
+                        core: input.core,
+                        identity,
+                        operation: envelope.operation.mutationKind === 'append-comment'
+                            ? {
+                                ...envelope.operation,
+                                payload: {
+                                    comment: {
+                                        ...envelope.operation.payload.comment,
+                                        author: localAuthorizationActor,
+                                        submittedAuthor: localAuthorizationActor,
+                                    },
+                                },
+                            }
+                            : envelope.operation,
+                        now: acceptedAt,
+                        actorRef: localAuthorizationActor,
+                        onPostCommitError: input.onPostCommitError,
+                    })
+                    : envelope.domain === 'taxonomy'
+                        && envelope.mutationKind === 'replace-state-with-task-remaps'
+                        ? enqueueLocalTaxonomyCompositeReplacement({
+                            store,
+                            core: input.core,
+                            identity,
+                            taxonomyState: envelope.taxonomyState,
+                            taskPatches: envelope.taskPatches,
+                            now: acceptedAt,
+                            onPostCommitError: input.onPostCommitError,
+                        })
+                        : envelope.domain === 'taxonomy'
+                            ? enqueueLocalTaxonomyReplacement({
+                                store,
+                                core: input.core,
+                                identity,
+                                taxonomyState: envelope.taxonomyState,
+                                now: acceptedAt,
+                                onPostCommitError: input.onPostCommitError,
+                            })
+                            : envelope.domain === 'task-relationship'
+                                ? enqueueLocalTaskRelationshipMutation({
+                                    store,
+                                    core: input.core,
+                                    identity,
+                                    relationshipId: envelope.entityId,
+                                    sourceTaskId: envelope.sourceTaskId,
+                                    targetTaskId: envelope.targetTaskId,
+                                    type: envelope.type,
+                                    mutationKind: envelope.mutationKind,
+                                    now: acceptedAt,
+                                    actorRef: 'user',
+                                    onPostCommitError: input.onPostCommitError,
+                                })
+                                : envelope.domain === 'task-comments'
+                                    ? enqueueLocalTaskCommentMutation({
+                                        store,
+                                        core: input.core,
+                                        identity,
+                                        taskId: envelope.entityId,
+                                        comment: {
+                                            ...envelope.comment,
+                                            author: localAuthorizationActor,
+                                            submittedAuthor: localAuthorizationActor,
+                                        },
+                                        now: acceptedAt,
+                                        actorRef: localAuthorizationActor,
+                                        onPostCommitError: input.onPostCommitError,
+                                    })
+                                    : envelope.domain === 'task-checklist'
+                                        ? enqueueLocalTaskChecklistMutation({
+                                            store,
+                                            core: input.core,
+                                            identity,
+                                            taskId: envelope.entityId,
+                                            items: envelope.items,
+                                            now: acceptedAt,
+                                            actorRef: 'user',
+                                            onPostCommitError: input.onPostCommitError,
+                                        })
+                                        : envelope.domain === 'task-attachment-links'
+                                            ? enqueueLocalTaskAttachmentLinksMutation({
+                                                store,
+                                                core: input.core,
+                                                identity,
+                                                taskId: envelope.entityId,
+                                                links: envelope.links,
+                                                ...(Object.prototype.hasOwnProperty.call(envelope, 'cardCoverAssetId')
+                                                    ? { cardCoverAssetId: envelope.cardCoverAssetId ?? null }
+                                                    : {}),
+                                                now: acceptedAt,
+                                                actorRef: 'user',
+                                                onPostCommitError: input.onPostCommitError,
+                                            })
+                                            : envelope.mutationKind === 'metadata-update'
+                                                ? enqueueLocalTaskMetadataMutation({
+                                                    store,
+                                                    core: input.core,
+                                                    identity,
+                                                    taskId: envelope.entityId,
+                                                    patch: envelope.patch,
+                                                    saveSource: envelope.saveSource,
+                                                    now: acceptedAt,
+                                                    actorRef: 'user',
+                                                    onPostCommitError: input.onPostCommitError,
+                                                })
+                                                : envelope.mutationKind === 'create'
+                                                    ? enqueueLocalTaskCreateMutation({
+                                                        store,
+                                                        core: input.core,
+                                                        identity,
+                                                        taskId: envelope.entityId,
+                                                        task: envelope.task,
+                                                        localCarriers: {
+                                                            ...envelope.localCarriers,
+                                                            comments: (envelope.localCarriers.comments || []).map((comment) => ({
+                                                                ...comment,
+                                                                author: localAuthorizationActor,
+                                                                submittedAuthor: localAuthorizationActor,
+                                                            })),
+                                                        },
+                                                        captureAttachmentLinks: resolveTaskAttachmentLinksMutationCapability({
+                                                            runtimeMode: 'local', surface: 'http', env: process.env,
+                                                        }),
+                                                        now: acceptedAt,
+                                                        actorRef: localAuthorizationActor,
+                                                        onPostCommitError: input.onPostCommitError,
+                                                    })
+                                                    : envelope.mutationKind === 'delete'
+                                                        ? enqueueLocalTaskDeleteMutation({
+                                                            store,
+                                                            core: input.core,
+                                                            identity,
+                                                            taskId: envelope.entityId,
+                                                            now: acceptedAt,
+                                                            actorRef: 'user',
+                                                            onPostCommitError: input.onPostCommitError,
+                                                        })
+                                                        : envelope.mutationKind === 'restore'
+                                                            ? enqueueLocalTaskRestoreMutation({
+                                                                store,
+                                                                core: input.core,
+                                                                identity,
+                                                                deletedRecordId: envelope.deletedRecordId,
+                                                                taskId: envelope.entityId,
+                                                                restoreDestination: envelope.restoreDestination,
+                                                                now: acceptedAt,
+                                                                actorRef: 'user',
+                                                                onPostCommitError: input.onPostCommitError,
+                                                            })
+                                                            : envelope.mutationKind === 'set-status'
+                                                                ? enqueueLocalTaskStatusMutation({
+                                                                    store,
+                                                                    core: input.core,
+                                                                    identity,
+                                                                    taskId: envelope.entityId,
+                                                                    payload: envelope.payload,
+                                                                    now: acceptedAt,
+                                                                    actorRef: 'user',
+                                                                    onPostCommitError: input.onPostCommitError,
+                                                                })
+                                                                : enqueueLocalTaskLifecycleMutation({
+                                                                    store,
+                                                                    core: input.core,
+                                                                    identity,
+                                                                    taskId: envelope.entityId,
+                                                                    mutationKind: envelope.mutationKind,
+                                                                    payload: envelope.payload,
+                                                                    now: acceptedAt,
+                                                                    actorRef: 'user',
+                                                                    onPostCommitError: input.onPostCommitError,
+                                                                });
+            const task = (envelope.domain === 'task' && envelope.mutationKind !== 'delete')
+                || envelope.domain === 'task-comments'
+                || envelope.domain === 'task-checklist'
+                || envelope.domain === 'task-attachment-links'
+                ? ('task' in result ? result.task : undefined)
+                    || input.core.getTask(envelope.entityId, envelope.workspaceId)
+                : undefined;
+            const deleted = envelope.domain === 'task' && envelope.mutationKind === 'delete'
+                ? ('deleted' in result ? result.deleted : undefined)
+                    || input.core.getDeletedTask(envelope.entityId, envelope.workspaceId)
+                : undefined;
+            const relationship = envelope.domain === 'task-relationship'
+                ? ('relationship' in result ? result.relationship : undefined)
+                    || input.core.getTaskRelationshipForSync(envelope.entityId, envelope.workspaceId)
+                : undefined;
+            const taxonomyState = envelope.domain === 'taxonomy'
+                ? ('taxonomyState' in result ? result.taxonomyState : undefined)
+                    || input.core.getTaxonomyState(envelope.workspaceId)
+                : undefined;
+            const initiative = envelope.domain === 'initiative'
+                ? ('initiative' in result ? result.initiative : undefined)
+                    || input.core.getInitiative(envelope.entityId, envelope.workspaceId)
+                : undefined;
+            const workstream = envelope.domain === 'workstream'
+                ? ('workstream' in result ? result.workstream : undefined)
+                    || input.core.getWorkstream(envelope.entityId, envelope.workspaceId)
+                : undefined;
+            if (envelope.domain === 'task' && envelope.mutationKind !== 'delete' && !task) {
+                throw new DurableTaskMetadataMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+            }
+            if (envelope.domain === 'task-comments' && !task) {
+                throw new LocalAuthoritativeTaskCommentError('Captured task comment parent not found.');
+            }
+            if (envelope.domain === 'task-checklist' && !task) {
+                throw new LocalAuthoritativeTaskChecklistError('Captured task checklist parent not found.');
+            }
+            if (envelope.domain === 'task-attachment-links' && !task) {
+                throw new LocalAuthoritativeTaskAttachmentLinksError('Captured task attachment-link parent not found.');
+            }
+            if (envelope.domain === 'task' && envelope.mutationKind === 'delete' && !deleted) {
+                throw new DurableTaskDeleteMutationError('Deleted task history not found.', 'TASK_DELETE_FAILED', 409);
+            }
+            if (envelope.domain === 'task-relationship' && !relationship) {
+                throw new LocalAuthoritativeTaskRelationshipError('Captured task relationship not found.');
+            }
+            writeJson(res, result.enqueued ? 202 : 200, {
+                success: true,
+                contractVersion: 3,
+                state: 'pending',
+                replayed: !result.enqueued,
+                workspaceId: envelope.workspaceId,
+                clientId,
+                operationId: envelope.operationId,
+                ...(task ? { task } : {}),
+                ...(deleted ? { deleted } : {}),
+                ...(relationship ? { relationship } : {}),
+                ...(taxonomyState ? { taxonomyState } : {}),
+                ...(initiative ? { initiative } : {}),
+                ...(workstream ? { workstream } : {}),
+            });
+        }
+        catch (error) {
+            let statusCode = 500;
+            let code = 'WORKSPACE_SYNC_LOCAL_CAPTURE_INTERNAL_ERROR';
+            let message = 'Failed to capture local workspace sync operation.';
+            if (error instanceof LocalCaptureRequestError
+                || error instanceof DurableTaskMetadataMutationError
+                || error instanceof DurableTaskCreateMutationError
+                || error instanceof DurableTaskDeleteMutationError
+                || error instanceof DurableTaskRestoreMutationError
+                || error instanceof DurableTaskRelationshipMutationError
+                || error instanceof DurableTaskLifecycleMutationError
+                || error instanceof DurableTaskWorkflowMutationError
+                || error instanceof DurableTaskStatusMutationError
+                || error instanceof DurableTaxonomyMutationError
+                || error instanceof DurableInitiativeMutationError
+                || error instanceof DurableInitiativeApplyError
+                || error instanceof DurableWorkstreamMutationError
+                || error instanceof DurableWorkstreamApplyError) {
+                statusCode = error.statusCode;
+                code = error.code;
+                message = error.message;
+            }
+            else if (error instanceof WorkspaceSyncIdempotencyConflictError
+                || error instanceof WorkspaceSyncEntityBusyError
+                || error instanceof EntityEventIdentityCollisionError
+                || error instanceof LocalAuthoritativeTaskCommentError
+                || error instanceof LocalAuthoritativeTaskChecklistError
+                || error instanceof LocalAuthoritativeTaskAttachmentLinksError) {
+                statusCode = 409;
+                code = error.code;
+                message = error.message;
+            }
+            else if (typeof error?.statusCode === 'number') {
+                statusCode = Number(error.statusCode);
+                message = statusCode >= 500 ? message : String(error.message || message);
+                code = statusCode === 413 ? 'WORKSPACE_SYNC_LOCAL_PAYLOAD_TOO_LARGE' : 'WORKSPACE_SYNC_LOCAL_REQUEST_INVALID';
+            }
+            writeJson(res, statusCode, {
+                success: false,
+                error: message,
+                code,
+                ...(error instanceof WorkspaceSyncEntityBusyError ? {
+                    retryable: error.retryable,
+                    retryHint: error.retryHint,
+                    ...(error.retryAfterAt ? { retryAfterAt: error.retryAfterAt } : {}),
+                    ...(error.details ? { details: error.details } : {}),
+                } : {}),
+            });
+        }
+    });
+}