@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/v3/localTaskCreateOutboxHandler.js

@@ -0,0 +1,147 @@
+import { EntityEventIdentityCollisionError } from '../../core/TaskActivityService.js';
+import { DurableTaskCreateMutationError, validateDurableTaskCreateInput } from '../../core/TaskDurableCreateMutationService.js';
+import { TaskforceRuleError } from '../../core/Taskforce.js';
+import { applyAuthoritativeTaskCreateAndAck, LocalAuthoritativeTaskCreateError, } from './localTaskCreateOutboxService.js';
+import { fingerprintWorkspaceSyncPayload, WorkspaceSyncIdempotencyConflictError, WorkspaceSyncRevisionConflictError, } from './syncDurabilityStore.js';
+import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+function buildTaskCreateEnvelope(record) {
+    let payload;
+    try {
+        payload = JSON.parse(record.payloadJson);
+    }
+    catch {
+        throw new Error('Local outbox payload is not valid JSON.');
+    }
+    if (fingerprintWorkspaceSyncPayload(payload) !== record.payloadFingerprint) {
+        throw new Error('Local outbox payload fingerprint does not match persisted content.');
+    }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new Error('Local outbox payload must be an object.');
+    }
+    const payloadRecord = payload;
+    const payloadKeys = Object.keys(payloadRecord).sort();
+    const allowedPayloadKeys = new Set(['task', 'localCarriers', 'attachmentLinks', 'originActor']);
+    if (!Object.prototype.hasOwnProperty.call(payloadRecord, 'task')
+        || payloadKeys.some((key) => !allowedPayloadKeys.has(key))) {
+        throw new Error('Local task create outbox payload must contain task and optional localCarriers/attachmentLinks/originActor.');
+    }
+    if (record.baseEntityRevision !== '0' || record.baseLifecycleRevision !== '0') {
+        throw new Error('Local task create outbox base revisions must both be 0.');
+    }
+    const localCarriers = payloadRecord.localCarriers;
+    const comments = serializeWorkspaceSyncV3TaskCommentsPayload({
+        taskId: record.entityId,
+        comments: Array.isArray(localCarriers?.comments) ? localCarriers.comments : [],
+    }).comments;
+    const checklist = serializeWorkspaceSyncV3TaskChecklistPayload({
+        taskId: record.entityId,
+        // New-task form drafts do not know their durable task id yet. The
+        // captured create identity owns that coordinate, so install it before
+        // validating and sending the canonical aggregate.
+        items: Array.isArray(localCarriers?.checklistItems)
+            ? localCarriers.checklistItems.map((item) => ({ ...item, taskId: record.entityId }))
+            : [],
+    }).items;
+    const attachments = serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+        taskId: record.entityId,
+        links: Array.isArray(payloadRecord.attachmentLinks) ? payloadRecord.attachmentLinks : [],
+    }).links;
+    let originActor;
+    if (payloadRecord.originActor !== undefined) {
+        const actor = payloadRecord.originActor;
+        if (!actor || typeof actor !== 'object' || Array.isArray(actor)) {
+            throw new Error('Local task create origin actor must be an object.');
+        }
+        const actorRecord = actor;
+        if (Object.keys(actorRecord).sort().join(',') !== 'kind,profileId'
+            || actorRecord.kind !== 'ai-profile'
+            || typeof actorRecord.profileId !== 'string'
+            || !actorRecord.profileId.trim().startsWith('ai-profile-')) {
+            throw new Error('Local task create origin actor is invalid.');
+        }
+        originActor = { kind: 'ai-profile', profileId: actorRecord.profileId.trim() };
+    }
+    return {
+        contractVersion: 3,
+        workspaceId: record.workspaceId,
+        clientId: record.clientId,
+        operationId: record.operationId,
+        operation: {
+            domain: 'task',
+            entityId: record.entityId,
+            mutationKind: 'create',
+            baseEntityRevision: '0',
+            baseLifecycleRevision: '0',
+            payload: {
+                task: validateDurableTaskCreateInput(payloadRecord.task),
+                ...(comments.length > 0 ? { comments } : {}),
+                ...(checklist.length > 0 ? { checklist } : {}),
+                ...(attachments.length > 0 ? { attachments } : {}),
+                ...(originActor ? { originActor } : {}),
+            },
+        },
+    };
+}
+export function createLocalTaskCreateOutboxHandler(input) {
+    return {
+        key: 'task/create',
+        supports: (record) => {
+            if (record.domain !== 'task' || record.mutationKind !== 'create')
+                return false;
+            try {
+                const payload = JSON.parse(record.payloadJson);
+                return Object.prototype.hasOwnProperty.call(payload, 'task')
+                    && !Object.prototype.hasOwnProperty.call(payload, 'adoptedRoot');
+            }
+            catch {
+                return false;
+            }
+        },
+        buildEnvelope: buildTaskCreateEnvelope,
+        resolveDispatchReadiness: (record) => {
+            const payload = buildTaskCreateEnvelope(record).operation.payload;
+            if (payload.task.workstreamId) {
+                const dependency = input.store.readCreateDependencyState({
+                    tenantId: record.tenantId,
+                    workspaceId: record.workspaceId,
+                    dependencies: [{ domain: 'workstream', entityId: payload.task.workstreamId }],
+                });
+                if (dependency) {
+                    return dependency === 'blocked'
+                        ? { ready: false, retryable: false, errorCode: 'WORKSPACE_SYNC_DEPENDENCY_BLOCKED',
+                            errorMessage: 'The required workstream create operation is blocked.' }
+                        : { ready: false, retryable: true, errorCode: 'WORKSPACE_SYNC_DEPENDENCY_PENDING',
+                            errorMessage: 'The required workstream create operation has not been accepted yet.' };
+                }
+            }
+            for (const attachment of payload.attachments || []) {
+                const readiness = input.core.getWorkspaceAssetDispatchReadiness(attachment.assetId, record.workspaceId);
+                if (!readiness.ready) {
+                    return {
+                        ready: false,
+                        retryable: readiness.retryable,
+                        errorCode: readiness.retryable
+                            ? 'TASK_ATTACHMENT_ASSET_NOT_READY'
+                            : 'TASK_ATTACHMENT_ASSET_INVALID',
+                        errorMessage: readiness.reason,
+                    };
+                }
+            }
+            return { ready: true };
+        },
+        applyAuthoritative: (applyInput) => {
+            applyAuthoritativeTaskCreateAndAck({
+                store: input.store,
+                core: input.core,
+                ...applyInput,
+                onPostCommitError: input.onPostCommitError,
+            });
+        },
+        isPermanentApplyError: (error) => (error instanceof LocalAuthoritativeTaskCreateError
+            || error instanceof DurableTaskCreateMutationError
+            || error instanceof TaskforceRuleError
+            || error instanceof WorkspaceSyncIdempotencyConflictError
+            || error instanceof WorkspaceSyncRevisionConflictError
+            || error instanceof EntityEventIdentityCollisionError),
+    };
+}

package/dist/sync/v3/localTaskCreateOutboxService.d.ts

@@ -0,0 +1,77 @@
+import type { EntityEvent, TaskItem } from '../../core/Taskforce.js';
+import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOperationIdentity } from './syncDurabilityStore.js';
+import { type WorkspaceSyncV3TaskAttachmentLink } from './workspaceSyncV3NestedTaskCodecs.js';
+export interface LocalTaskCreateOutboxCore {
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    createTask(input: Partial<TaskItem>, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        workspaceId?: string;
+        allowClientProvidedId?: boolean;
+        provisionalLocalReference?: boolean;
+        durableProvisionalCreate?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        taskEventId?: string;
+        allowV3OwnedCreate?: boolean;
+        preferExplicitAttachmentAssetId?: boolean;
+    }): TaskItem;
+    installDurableTaskCreateAuthoritativeForSync(task: TaskItem, workspaceId: string): TaskItem;
+    upsertEntityEventForSync(event: EntityEvent, options?: {
+        allowAuthoritativeReplacement?: boolean;
+    }): unknown;
+    notifyDurableTaskCreateCommitted(workspaceId: string, taskId: string): void;
+    listTaskAttachmentLinksForDurableSync(taskId: string, workspaceId: string): WorkspaceSyncV3TaskAttachmentLink[];
+    resolveTaskAttachmentLinksForDurableSync(links: readonly WorkspaceSyncV3TaskAttachmentLink[], workspaceId: string, options?: {
+        requireDispatchReady?: boolean;
+        adoptAuthoritativeReferenceNumber?: boolean;
+        ignoreAssetMetadataSnapshots?: boolean;
+    }): TaskItem['attachments'];
+    normalizeTaskAttachmentDescriptorsForDurableSync(attachments: readonly NonNullable<TaskItem['attachments']>[number][], workspaceId: string, options?: {
+        requireDispatchReady?: boolean;
+    }): WorkspaceSyncV3TaskAttachmentLink[];
+    getWorkspaceAssetDispatchReadiness(assetId: string, workspaceId: string): {
+        ready: boolean;
+        retryable: boolean;
+        reason: string;
+    };
+    updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        syncUpdatedAt?: string;
+        skipTaskEvents?: boolean;
+        allowV3OwnedMetadataWrite?: boolean;
+        allowArchivedNestedContentSyncWrite?: boolean;
+        preferExplicitAttachmentRole?: boolean;
+        preferExplicitAttachmentAssetId?: boolean;
+    }): TaskItem | null;
+}
+export declare class LocalAuthoritativeTaskCreateError extends Error {
+    readonly code = "WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID";
+    constructor(message: string);
+}
+export declare function enqueueLocalTaskCreateMutation(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: LocalTaskCreateOutboxCore;
+    identity: WorkspaceSyncOperationIdentity;
+    taskId: string;
+    task: Partial<TaskItem>;
+    localCarriers?: Pick<TaskItem, 'attachments' | 'checklistItems' | 'comments'>;
+    now: string;
+    actorRef: string;
+    requireV3CombinedOwnership?: boolean;
+    captureAttachmentLinks?: boolean;
+    onPostCommitError?: (error: unknown) => void;
+}): {
+    enqueued: boolean;
+    task?: TaskItem;
+};
+export declare function applyAuthoritativeTaskCreateAndAck(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: LocalTaskCreateOutboxCore;
+    identity: WorkspaceSyncOperationIdentity;
+    leaseOwner: string;
+    response: unknown;
+    now: string;
+    onPostCommitError?: (error: unknown) => void;
+}): TaskItem;

package/dist/sync/v3/localTaskCreateOutboxService.js

@@ -0,0 +1,397 @@
+import { DurableTaskCreateMutationError, validateDurableTaskCreateInput, } from '../../core/TaskDurableCreateMutationService.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { buildTaskCreateActivityEventId } from './taskCreateActivityIdentity.js';
+import { validateTaskActivityAuthoritativeRevision } from './taskActivityAuthoritativeRevision.js';
+import { serializeEntityActivityForSync, serializeTaskActivityForSync, WORKSPACE_SYNC_ENTITY_EVENT_APPEND, WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN, } from './taskActivityJournal.js';
+import { fingerprintWorkspaceSyncPayload, } from './syncDurabilityStore.js';
+import { serializeTaskRootForSync } from './workspaceSyncV3TaskRootProjection.js';
+import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3TaskChecklistPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+export class LocalAuthoritativeTaskCreateError extends Error {
+    code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'LocalAuthoritativeTaskCreateError';
+    }
+}
+export function enqueueLocalTaskCreateMutation(input) {
+    const taskId = String(input.taskId || '').trim();
+    if (!taskId)
+        throw new DurableTaskCreateMutationError('Task id is required.', 'TASK_CREATE_INVALID', 400);
+    const task = validateDurableTaskCreateInput(input.task);
+    const localCarriers = input.localCarriers || { attachments: [], checklistItems: [], comments: [] };
+    if (!Array.isArray(localCarriers.attachments)
+        || !Array.isArray(localCarriers.checklistItems)
+        || !Array.isArray(localCarriers.comments)) {
+        throw new DurableTaskCreateMutationError('Task create local carriers must be arrays.', 'TASK_CREATE_INVALID', 400);
+    }
+    const attachmentLinks = input.captureAttachmentLinks && localCarriers.attachments.length > 0
+        ? input.core.normalizeTaskAttachmentDescriptorsForDurableSync(localCarriers.attachments, input.identity.workspaceId, { requireDispatchReady: false })
+        : [];
+    const activityEventId = buildTaskCreateActivityEventId({
+        workspaceId: input.identity.workspaceId,
+        clientId: input.identity.clientId,
+        operationId: input.identity.operationId,
+        taskId,
+    });
+    const enqueued = input.store.enqueueLocalOperation({
+        identity: input.identity,
+        domain: 'task',
+        entityId: taskId,
+        mutationKind: 'create',
+        revisionSource: 'current',
+        payload: {
+            task,
+            localCarriers,
+            ...(attachmentLinks.length > 0 ? { attachmentLinks } : {}),
+            ...(String(input.actorRef || '').trim().startsWith('ai-profile-')
+                ? { originActor: { kind: 'ai-profile', profileId: String(input.actorRef).trim() } }
+                : {}),
+        },
+        ...(input.requireV3CombinedOwnership ? { requireV3PlanningOwnership: 'combined' } : {}),
+        additionalTargets: [
+            ...(localCarriers.comments.length > 0 ? [{
+                    domain: 'task-comments', entityId: taskId, mutationKind: 'replace',
+                    baseEntityRevision: 0, baseLifecycleRevision: 0,
+                }] : []),
+            ...(localCarriers.checklistItems.length > 0 ? [{
+                    domain: 'task-checklist', entityId: taskId, mutationKind: 'replace',
+                    baseEntityRevision: 0, baseLifecycleRevision: 0,
+                }] : []),
+            ...(attachmentLinks.length > 0 ? [{
+                    domain: 'task-attachment-links', entityId: taskId, mutationKind: 'replace',
+                    baseEntityRevision: 0, baseLifecycleRevision: 0,
+                }] : []),
+        ],
+        now: input.now,
+        applyLocalMutation: () => {
+            const created = input.core.createTask({
+                ...task,
+                ...localCarriers,
+                id: taskId,
+                createdAt: input.now,
+                updatedAt: input.now,
+                createdBy: input.actorRef,
+            }, {
+                workspaceId: input.identity.workspaceId,
+                allowClientProvidedId: true,
+                durableProvisionalCreate: true,
+                persistBackup: false,
+                emitRealtime: false,
+                syncUpdatedAt: input.now,
+                actorRef: input.actorRef,
+                taskEventId: activityEventId,
+                allowV3OwnedCreate: true,
+                preferExplicitAttachmentAssetId: true,
+            });
+            if (created.id !== taskId || created.referenceNumber !== null || !created.localReferenceNumber) {
+                throw new DurableTaskCreateMutationError('Local durable create did not produce a provisional task identity.', 'TASK_CREATE_FAILED', 500);
+            }
+            return created;
+        },
+    });
+    if (!enqueued.enqueued)
+        return { enqueued: false };
+    try {
+        input.core.notifyDurableTaskCreateCommitted(input.identity.workspaceId, taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* local create and outbox remain committed */ }
+    }
+    return { enqueued: true, task: enqueued.mutationResult };
+}
+export function applyAuthoritativeTaskCreateAndAck(input) {
+    if (!input.response || typeof input.response !== 'object' || Array.isArray(input.response)) {
+        throw new LocalAuthoritativeTaskCreateError('Authoritative task create response must be an object.');
+    }
+    const response = input.response;
+    const authoritative = response.authoritative;
+    const task = authoritative?.payload;
+    if (response.success !== true
+        || response.contractVersion !== 3
+        || response.workspaceId !== input.identity.workspaceId
+        || response.clientId !== input.identity.clientId
+        || response.operationId !== input.identity.operationId
+        || response.provisionalTaskId !== authoritative?.entityId
+        || authoritative?.domain !== 'task'
+        || authoritative.mutationKind !== 'create'
+        || typeof response.acceptedSequence !== 'string'
+        || !/^(0|[1-9]\d*)$/.test(response.acceptedSequence)
+        || typeof authoritative.entityRevision !== 'string'
+        || !/^(0|[1-9]\d*)$/.test(authoritative.entityRevision)
+        || typeof authoritative.lifecycleRevision !== 'string'
+        || !/^(0|[1-9]\d*)$/.test(authoritative.lifecycleRevision)
+        || !task || typeof task !== 'object'
+        || task.id !== response.provisionalTaskId
+        || !Number.isInteger(Number(task.referenceNumber))
+        || Number(task.referenceNumber) < 1) {
+        throw new LocalAuthoritativeTaskCreateError('Authoritative task create response identity is invalid.');
+    }
+    const activity = response.activity;
+    const commentProjection = response.commentProjection;
+    const checklistProjection = response.checklistProjection;
+    const attachmentProjection = response.attachmentProjection;
+    const capturedRecord = input.store.readOutboxOperation(input.identity);
+    let capturedChecklistItems = false;
+    let capturedAttachmentLinks = false;
+    try {
+        const capturedPayload = capturedRecord ? JSON.parse(capturedRecord.payloadJson) : null;
+        const capturedLocalCarriers = capturedPayload?.localCarriers;
+        capturedChecklistItems = Boolean(capturedLocalCarriers
+            && typeof capturedLocalCarriers === 'object'
+            && !Array.isArray(capturedLocalCarriers)
+            && Array.isArray(capturedLocalCarriers.checklistItems)
+            && capturedLocalCarriers.checklistItems.length > 0);
+        capturedAttachmentLinks = Array.isArray(capturedPayload?.attachmentLinks)
+            && capturedPayload.attachmentLinks.length > 0;
+    }
+    catch {
+        throw new LocalAuthoritativeTaskCreateError('Captured task create payload is invalid.');
+    }
+    if (capturedChecklistItems && !checklistProjection) {
+        throw new LocalAuthoritativeTaskCreateError('Authoritative task create response omitted the captured checklist projection.');
+    }
+    if (capturedAttachmentLinks && !attachmentProjection) {
+        throw new LocalAuthoritativeTaskCreateError('Authoritative task create response omitted the captured attachment-link projection.');
+    }
+    const expectedActivityId = buildTaskCreateActivityEventId({
+        workspaceId: input.identity.workspaceId,
+        clientId: input.identity.clientId,
+        operationId: input.identity.operationId,
+        taskId: task.id,
+    });
+    if (!activity || typeof activity !== 'object'
+        || activity.id !== expectedActivityId
+        || activity.workspaceId !== input.identity.workspaceId
+        || activity.entityType !== 'task'
+        || activity.entityId !== task.id
+        || activity.taskId !== task.id
+        || activity.action !== 'task-created'
+        || typeof activity.actor !== 'string' || !activity.actor.trim()
+        || !['human', 'ai', 'system'].includes(activity.actorType)
+        || typeof task.createdAt !== 'string'
+        || !Number.isFinite(Date.parse(task.createdAt))
+        || new Date(task.createdAt).toISOString() !== task.createdAt
+        || typeof task.updatedAt !== 'string'
+        || !Number.isFinite(Date.parse(task.updatedAt))
+        || new Date(task.updatedAt).toISOString() !== task.updatedAt
+        || task.createdAt !== task.updatedAt
+        || typeof activity.createdAt !== 'string'
+        || !Number.isFinite(Date.parse(activity.createdAt))
+        || new Date(activity.createdAt).toISOString() !== activity.createdAt
+        || activity.createdAt !== task.createdAt
+        || !activity.details || typeof activity.details !== 'object' || Array.isArray(activity.details)
+        || Object.keys(activity.details).sort().join(',') !== 'status,title,workstreamId'
+        || activity.details.title !== task.title
+        || activity.details.status !== task.status
+        || (activity.details.workstreamId ?? null) !== (task.workstreamId ?? null)) {
+        throw new LocalAuthoritativeTaskCreateError('Authoritative task create activity is invalid.');
+    }
+    const revision = validateTaskActivityAuthoritativeRevision({
+        response: response,
+        authoritative: authoritative,
+        activityId: activity.id,
+        intermediateRevisions: [
+            ...(commentProjection ? [{ sequence: commentProjection.sequence }] : []),
+            ...(checklistProjection ? [{ sequence: checklistProjection.sequence }] : []),
+            ...(attachmentProjection ? [{ sequence: attachmentProjection.sequence }] : []),
+        ],
+        invalid: (message) => new LocalAuthoritativeTaskCreateError(message),
+    });
+    const dependentActivities = Array.isArray(response.dependentActivities) ? response.dependentActivities : [];
+    if (dependentActivities.length !== revision.dependentActivityRevisions.length) {
+        throw new LocalAuthoritativeTaskCreateError('Dependent task create activity is incomplete.');
+    }
+    const canonicalDependentActivities = dependentActivities.map((event, index) => {
+        try {
+            const canonical = serializeEntityActivityForSync(event);
+            if (canonical.id !== revision.dependentActivityRevisions[index].entityId
+                || canonical.workspaceId !== input.identity.workspaceId
+                || canonical.entityType !== 'workstream'
+                || canonical.details?.taskId !== task.id)
+                throw new Error('identity mismatch');
+            return canonical;
+        }
+        catch {
+            throw new LocalAuthoritativeTaskCreateError('Dependent task create activity is invalid.');
+        }
+    });
+    let canonicalCommentProjection = null;
+    if (commentProjection) {
+        if (commentProjection.domain !== 'task-comments' || commentProjection.entityId !== task.id
+            || commentProjection.mutationKind !== 'replace'
+            || !/^(0|[1-9]\d*)$/.test(commentProjection.sequence)
+            || !/^(0|[1-9]\d*)$/.test(commentProjection.entityRevision)
+            || commentProjection.lifecycleRevision !== '0') {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create comment projection is invalid.');
+        }
+        canonicalCommentProjection = serializeWorkspaceSyncV3TaskCommentsPayload({
+            taskId: task.id, comments: commentProjection.payload.comments,
+        });
+        if (fingerprintWorkspaceSyncPayload(canonicalCommentProjection) !== fingerprintWorkspaceSyncPayload(serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: task.id, comments: task.comments || [] })))
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create comments do not match the task payload.');
+    }
+    let canonicalChecklistProjection = null;
+    if (checklistProjection) {
+        if (checklistProjection.domain !== 'task-checklist' || checklistProjection.entityId !== task.id
+            || checklistProjection.mutationKind !== 'replace'
+            || !/^(0|[1-9]\d*)$/.test(checklistProjection.sequence)
+            || !/^(0|[1-9]\d*)$/.test(checklistProjection.entityRevision)
+            || checklistProjection.lifecycleRevision !== '0') {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create checklist projection is invalid.');
+        }
+        try {
+            canonicalChecklistProjection = validateWorkspaceSyncV3TaskChecklistPayload(checklistProjection.payload);
+        }
+        catch {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create checklist payload is invalid.');
+        }
+        if (canonicalChecklistProjection.taskId !== task.id) {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create checklist identity is invalid.');
+        }
+        if (fingerprintWorkspaceSyncPayload(canonicalChecklistProjection) !== fingerprintWorkspaceSyncPayload(serializeWorkspaceSyncV3TaskChecklistPayload({ taskId: task.id, items: task.checklistItems || [] })))
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create checklist does not match the task payload.');
+    }
+    let canonicalAttachmentProjection = null;
+    if (attachmentProjection) {
+        if (attachmentProjection.domain !== 'task-attachment-links' || attachmentProjection.entityId !== task.id
+            || attachmentProjection.mutationKind !== 'replace'
+            || !/^(0|[1-9]\d*)$/.test(attachmentProjection.sequence)
+            || !/^(0|[1-9]\d*)$/.test(attachmentProjection.entityRevision)
+            || attachmentProjection.lifecycleRevision !== '0') {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create attachment-link projection is invalid.');
+        }
+        try {
+            canonicalAttachmentProjection = validateWorkspaceSyncV3TaskAttachmentLinksPayload(attachmentProjection.payload);
+        }
+        catch {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create attachment-link payload is invalid.');
+        }
+        if (canonicalAttachmentProjection.taskId !== task.id) {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create attachment-link identity is invalid.');
+        }
+        const capturedAttachmentProjection = serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+            taskId: task.id,
+            links: input.core.listTaskAttachmentLinksForDurableSync(task.id, input.identity.workspaceId),
+        });
+        const relationshipIntent = (projection) => ({
+            taskId: projection.taskId,
+            links: projection.links.map(({ assetId, role, order, displayName }) => ({
+                assetId,
+                role,
+                order,
+                ...(displayName ? { displayName } : {}),
+            })),
+        });
+        if (fingerprintWorkspaceSyncPayload(relationshipIntent(canonicalAttachmentProjection))
+            !== fingerprintWorkspaceSyncPayload(relationshipIntent(capturedAttachmentProjection))) {
+            throw new LocalAuthoritativeTaskCreateError('Authoritative task create attachment links do not match the captured projection.');
+        }
+    }
+    const canonicalFingerprint = fingerprintWorkspaceSyncPayload(serializeTaskForSync(task));
+    const installed = input.store.applyAuthoritativeAndAck({
+        identity: input.identity,
+        leaseOwner: input.leaseOwner,
+        now: input.now,
+        response,
+        acceptedSequence: revision.operationHighWatermark,
+        authoritative: [{
+                domain: 'task',
+                entityId: task.id,
+                mutationKind: 'create',
+                entityRevision: authoritative.entityRevision,
+                lifecycleRevision: authoritative.lifecycleRevision,
+                sequence: revision.taskSequence,
+                canonicalFingerprint,
+            }, ...(commentProjection && canonicalCommentProjection ? [{
+                    domain: 'task-comments',
+                    entityId: task.id,
+                    mutationKind: 'replace',
+                    entityRevision: commentProjection.entityRevision,
+                    lifecycleRevision: commentProjection.lifecycleRevision,
+                    sequence: commentProjection.sequence,
+                    canonicalFingerprint: fingerprintWorkspaceSyncPayload(canonicalCommentProjection),
+                }] : []), ...(checklistProjection && canonicalChecklistProjection ? [{
+                    domain: 'task-checklist',
+                    entityId: task.id,
+                    mutationKind: 'replace',
+                    entityRevision: checklistProjection.entityRevision,
+                    lifecycleRevision: checklistProjection.lifecycleRevision,
+                    sequence: checklistProjection.sequence,
+                    canonicalFingerprint: fingerprintWorkspaceSyncPayload(canonicalChecklistProjection),
+                }] : []), ...(attachmentProjection && canonicalAttachmentProjection ? [{
+                    domain: 'task-attachment-links',
+                    entityId: task.id,
+                    mutationKind: 'replace',
+                    entityRevision: attachmentProjection.entityRevision,
+                    lifecycleRevision: attachmentProjection.lifecycleRevision,
+                    sequence: attachmentProjection.sequence,
+                    canonicalFingerprint: fingerprintWorkspaceSyncPayload(canonicalAttachmentProjection),
+                }] : []), ...(!revision.legacySingleEntry && revision.activityRevision ? [{
+                    domain: WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN,
+                    entityId: activity.id,
+                    mutationKind: WORKSPACE_SYNC_ENTITY_EVENT_APPEND,
+                    entityRevision: revision.activityRevision.entityRevision,
+                    lifecycleRevision: revision.activityRevision.lifecycleRevision,
+                    sequence: revision.activityRevision.sequence,
+                    canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(activity)),
+                }] : []), ...revision.dependentActivityRevisions.map((dependentRevision, index) => ({
+                domain: WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN,
+                entityId: dependentRevision.entityId,
+                mutationKind: WORKSPACE_SYNC_ENTITY_EVENT_APPEND,
+                entityRevision: dependentRevision.entityRevision,
+                lifecycleRevision: dependentRevision.lifecycleRevision,
+                sequence: dependentRevision.sequence,
+                canonicalFingerprint: fingerprintWorkspaceSyncPayload(canonicalDependentActivities[index]),
+            }))],
+        applyAuthoritative: () => {
+            const updated = input.core.installDurableTaskCreateAuthoritativeForSync({
+                ...task,
+                localReferenceNumber: null,
+            }, input.identity.workspaceId);
+            const installedWithAttachments = canonicalAttachmentProjection
+                ? input.core.updateTask(task.id, {
+                    attachments: input.core.resolveTaskAttachmentLinksForDurableSync(canonicalAttachmentProjection.links, input.identity.workspaceId, { adoptAuthoritativeReferenceNumber: true }),
+                }, input.identity.workspaceId, {
+                    persistBackup: false,
+                    emitRealtime: false,
+                    skipTaskEvents: true,
+                    syncUpdatedAt: updated.updatedAt,
+                    preferExplicitAttachmentRole: true,
+                    preferExplicitAttachmentAssetId: true,
+                    allowV3OwnedMetadataWrite: true,
+                    allowArchivedNestedContentSyncWrite: true,
+                })
+                : updated;
+            if (!installedWithAttachments) {
+                throw new LocalAuthoritativeTaskCreateError('Installed task disappeared while applying attachment links.');
+            }
+            input.core.upsertEntityEventForSync(activity, { allowAuthoritativeReplacement: true });
+            for (const dependentActivity of canonicalDependentActivities) {
+                input.core.upsertEntityEventForSync(dependentActivity, { allowAuthoritativeReplacement: true });
+            }
+            const installedMatchesAuthoritative = fingerprintWorkspaceSyncPayload(serializeTaskRootForSync(installedWithAttachments))
+                === fingerprintWorkspaceSyncPayload(serializeTaskRootForSync(task));
+            if (!installedMatchesAuthoritative && (installedWithAttachments.id !== task.id
+                || installedWithAttachments.referenceNumber !== task.referenceNumber
+                || installedWithAttachments.localReferenceNumber !== null
+                || installedWithAttachments.createdAt !== task.createdAt
+                || (installedWithAttachments.createdBy ?? null) !== (task.createdBy ?? null))) {
+                throw new LocalAuthoritativeTaskCreateError('Installed task create identity does not match the authoritative payload.');
+            }
+            return installedWithAttachments;
+        },
+    });
+    try {
+        input.core.notifyDurableTaskCreateCommitted(input.identity.workspaceId, task.id);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* authoritative create and ack remain committed */ }
+    }
+    return installed;
+}

package/dist/sync/v3/localTaskDeleteClient.d.ts

@@ -0,0 +1,10 @@
+import { type LocalTaskOperationClientDependencies, type LocalTaskOperationResult } from './localTaskOperationClient.js';
+export type LocalTaskDeleteMutationResult = LocalTaskOperationResult;
+export declare function createLocalTaskDeleteClient(dependencies?: LocalTaskOperationClientDependencies): {
+    delete(input: {
+        workspaceId: string;
+        entityId: string;
+        isAuthenticated: boolean;
+        dispatchEnabled?: boolean;
+    }): Promise<LocalTaskDeleteMutationResult>;
+};

package/dist/sync/v3/localTaskDeleteClient.js

@@ -0,0 +1,23 @@
+import { createLocalTaskOperationClient, requireLocalTaskOperationId, } from './localTaskOperationClient.js';
+const CAPTURE_DISABLED_CODES = new Set([
+    'WORKSPACE_SYNC_LOCAL_CAPTURE_DISABLED',
+    'WORKSPACE_SYNC_LOCAL_DELETE_CAPTURE_DISABLED',
+]);
+export function createLocalTaskDeleteClient(dependencies = {}) {
+    const client = createLocalTaskOperationClient(dependencies);
+    return {
+        delete(input) {
+            const workspaceId = requireLocalTaskOperationId(input.workspaceId, 'workspaceId');
+            const entityId = requireLocalTaskOperationId(input.entityId, 'entityId');
+            const operation = { domain: 'task', entityId, mutationKind: 'delete', payload: {} };
+            return client.execute({
+                workspaceId,
+                fingerprintValue: { contractVersion: 3, workspaceId, operation },
+                buildOperation: () => operation,
+                disabledCodes: CAPTURE_DISABLED_CODES,
+                isAuthenticated: input.isAuthenticated,
+                dispatchEnabled: input.dispatchEnabled,
+            });
+        },
+    };
+}

package/dist/sync/v3/localTaskDeleteOutboxHandler.d.ts

@@ -0,0 +1,8 @@
+import { type LocalTaskDeleteOutboxCore } from './localTaskDeleteOutboxService.js';
+import type { LocalOutboxOperationHandler } from './localOutboxOperationHandler.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+export declare function createLocalTaskDeleteOutboxHandler(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: LocalTaskDeleteOutboxCore;
+    onPostCommitError?: (error: unknown) => void;
+}): LocalOutboxOperationHandler;