@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/v3/taskDeleteMutationService.js

@@ -0,0 +1,133 @@
+import { applyTaskDeleteForDurableSync, DurableTaskDeleteMutationError, prepareTaskDeleteForDurableSync, } from '../../core/TaskDurableDeleteMutationService.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
+export function runDurableTaskDelete(input) {
+    const relationshipBases = [...input.relationshipBaseRevisions]
+        .map((entry) => ({ ...entry, entityId: String(entry.entityId || '').trim() }))
+        .sort((left, right) => left.entityId.localeCompare(right.entityId));
+    const identity = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+    };
+    const requestFingerprint = fingerprintWorkspaceSyncPayload({
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        identity,
+        operation: {
+            domain: 'task',
+            entityId: input.taskId,
+            mutationKind: 'delete',
+            baseEntityRevision: String(input.baseEntityRevision),
+            baseLifecycleRevision: String(input.baseLifecycleRevision),
+            relationships: relationshipBases.map((entry) => ({
+                entityId: entry.entityId,
+                baseEntityRevision: String(entry.baseEntityRevision),
+                baseLifecycleRevision: String(entry.baseLifecycleRevision),
+            })),
+        },
+    });
+    const existingOperation = input.store.readOperation({ identity, requestFingerprint });
+    if (existingOperation?.state === 'committed') {
+        return {
+            state: 'committed',
+            replayed: true,
+            responseJson: existingOperation.responseJson,
+            acceptedSequence: String(existingOperation.acceptedSequence),
+        };
+    }
+    const plan = prepareTaskDeleteForDurableSync({ core: input.core, workspaceId: input.workspaceId, taskId: input.taskId });
+    const plannedIds = plan.relationships.map((relationship) => relationship.id).sort();
+    if (relationshipBases.length !== plannedIds.length
+        || relationshipBases.some((entry, index) => entry.entityId !== plannedIds[index])) {
+        throw new DurableTaskDeleteMutationError('Relationship base revisions must exactly match the task relationships being deleted.', 'TASK_DELETE_RELATIONSHIP_SET_CHANGED', 409);
+    }
+    const reservation = input.store.reserveOperation({
+        identity,
+        requestFingerprint,
+        now: input.now,
+        leaseExpiresAt: input.leaseExpiresAt,
+        leaseOwner: input.leaseOwner,
+    });
+    if (reservation.state === 'in_progress')
+        return reservation;
+    if (reservation.state === 'committed') {
+        return {
+            state: 'committed',
+            replayed: true,
+            responseJson: reservation.responseJson,
+            acceptedSequence: String(reservation.acceptedSequence),
+        };
+    }
+    const entries = [
+        {
+            domain: 'task',
+            entityId: input.taskId,
+            mutationKind: 'delete',
+            revisionKind: 'both',
+            baseEntityRevision: input.baseEntityRevision,
+            baseLifecycleRevision: input.baseLifecycleRevision,
+            metadataOwned: () => true,
+            buildCanonicalFingerprint: (result) => fingerprintWorkspaceSyncPayload(result.taskTombstone),
+            buildAuthoritativePayload: (result) => result.taskTombstone,
+        },
+        ...relationshipBases.map((base) => ({
+            domain: 'task-relationship',
+            entityId: base.entityId,
+            mutationKind: 'delete',
+            revisionKind: 'both',
+            baseEntityRevision: base.baseEntityRevision,
+            baseLifecycleRevision: base.baseLifecycleRevision,
+            buildCanonicalFingerprint: (result) => fingerprintWorkspaceSyncPayload(result.relationshipTombstones.find((relationship) => relationship.id === base.entityId)),
+            buildAuthoritativePayload: (result) => result.relationshipTombstones.find((relationship) => relationship.id === base.entityId),
+        })),
+    ];
+    const accepted = input.store.acceptReservedOperationBatch({
+        identity,
+        requestFingerprint,
+        leaseOwner: reservation.leaseOwner,
+        now: input.now,
+        entries,
+        applyMutation: () => applyTaskDeleteForDurableSync({
+            core: input.core,
+            workspaceId: input.workspaceId,
+            taskId: input.taskId,
+            expectedRelationshipIds: plannedIds,
+            deletedAt: input.now,
+            actorRef: input.actorRef,
+        }),
+        buildResponse: (result, revisions) => ({
+            success: true,
+            contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+            workspaceId: input.workspaceId,
+            clientId: input.clientId,
+            operationId: input.operationId,
+            acceptedSequence: revisions.at(-1)?.sequence,
+            authoritative: revisions.map((revision) => ({
+                domain: revision.domain,
+                entityId: revision.entityId,
+                mutationKind: 'delete',
+                sequence: revision.sequence,
+                entityRevision: revision.entityRevision,
+                lifecycleRevision: revision.lifecycleRevision,
+                payload: revision.domain === 'task'
+                    ? result.taskTombstone
+                    : result.relationshipTombstones.find((relationship) => relationship.id === revision.entityId),
+            })),
+        }),
+    });
+    try {
+        input.core.notifyDurableTaskDeleteCommitted(input.workspaceId, input.taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* accepted mutation remains successful */ }
+    }
+    return {
+        state: 'committed',
+        replayed: false,
+        responseJson: accepted.responseJson,
+        acceptedSequence: accepted.acceptedSequence,
+    };
+}

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

@@ -0,0 +1,78 @@
+import { type DurableTaskCreateMutationCore } from '../../core/TaskDurableCreateMutationService.js';
+import type { TaskEvent, TaskItem } from '../../core/Taskforce.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { serializeTaskActivityForSync, type WorkspaceSyncActivityRevision } from './taskActivityJournal.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+import { type WorkspaceSyncV3TaskRootPayload } from './workspaceSyncV3TaskRootProjection.js';
+export declare class TaskLegacyRootAdoptionError extends Error {
+    readonly code = "TASK_LEGACY_ROOT_ADOPTION_INVALID";
+    readonly statusCode = 409;
+    constructor(message: string);
+}
+export interface TaskLegacyRootAdoptionCore extends DurableTaskCreateMutationCore {
+    createTask(input: Partial<TaskItem>, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        workspaceId?: string;
+        allowClientProvidedId?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        taskEventId?: string;
+        allowV3OwnedCreate?: boolean;
+    }): TaskItem;
+    installWorkspaceSyncV3TaskRootAuthoritativeForSync(task: TaskItem, workspaceId: string): TaskItem;
+    notifyDurableTaskCreateCommitted(workspaceId: string, taskId: string): void;
+    getTaskEventForSync(input: {
+        workspaceId: string;
+        taskId: string;
+        eventId: string;
+    }): TaskEvent | null;
+}
+export type DurableTaskLegacyRootAdoptionResponse = {
+    success: true;
+    contractVersion: 3;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    provisionalTaskId: string;
+    adoptedLegacyRoot: true;
+    acceptedSequence: string;
+    operationHighWatermark: string;
+    authoritative: {
+        domain: 'task';
+        entityId: string;
+        mutationKind: 'create';
+        sequence: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        payload: ReturnType<typeof serializeTaskForSync>;
+    };
+    activity: ReturnType<typeof serializeTaskActivityForSync>;
+    activityRevision: WorkspaceSyncActivityRevision;
+};
+export declare function validateTaskLegacyRootAdoptionCandidate(value: unknown, expectedTaskId: string): WorkspaceSyncV3TaskRootPayload;
+export declare function runDurableTaskLegacyRootAdoption(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: TaskLegacyRootAdoptionCore;
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    taskId: string;
+    adoptedRoot: unknown;
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    now: string;
+    leaseExpiresAt: string;
+    leaseOwner?: string;
+    actorRef: string;
+    onPostCommitError?: (error: unknown) => void;
+}): {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    replayed: boolean;
+    responseJson: string;
+    response: DurableTaskLegacyRootAdoptionResponse;
+};

package/dist/sync/v3/taskLegacyRootAdoptionService.js

@@ -0,0 +1,175 @@
+import { assertTaskCreateIdentityAvailable, } from '../../core/TaskDurableCreateMutationService.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { buildTaskCreateActivityEventId } from './taskCreateActivityIdentity.js';
+import { asWorkspaceSyncActivityRevision, buildTaskActivityJournalEntry, serializeTaskActivityForSync, } from './taskActivityJournal.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
+import { serializeTaskRootForSync, } from './workspaceSyncV3TaskRootProjection.js';
+const TASK_STATUSES = new Set(['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']);
+export class TaskLegacyRootAdoptionError extends Error {
+    code = 'TASK_LEGACY_ROOT_ADOPTION_INVALID';
+    statusCode = 409;
+    constructor(message) {
+        super(message);
+        this.name = 'TaskLegacyRootAdoptionError';
+    }
+}
+function canonicalTimestamp(value, label) {
+    const timestamp = String(value || '').trim();
+    if (!Number.isFinite(Date.parse(timestamp)) || new Date(timestamp).toISOString() !== timestamp) {
+        throw new TaskLegacyRootAdoptionError(`${label} must be a canonical ISO timestamp.`);
+    }
+    return timestamp;
+}
+export function validateTaskLegacyRootAdoptionCandidate(value, expectedTaskId) {
+    const root = serializeTaskRootForSync(value);
+    if (root.id !== expectedTaskId || !root.title || !root.type || !root.category) {
+        throw new TaskLegacyRootAdoptionError('Legacy task root identity and required metadata are invalid.');
+    }
+    if (!TASK_STATUSES.has(root.status) || root.isArchived === true || root.referenceNumber !== null) {
+        throw new TaskLegacyRootAdoptionError('Legacy task root state is not eligible for adoption.');
+    }
+    const createdAt = canonicalTimestamp(root.createdAt, 'Legacy task createdAt');
+    const updatedAt = canonicalTimestamp(root.updatedAt, 'Legacy task updatedAt');
+    if (Date.parse(updatedAt) < Date.parse(createdAt)) {
+        throw new TaskLegacyRootAdoptionError('Legacy task updatedAt cannot precede createdAt.');
+    }
+    if (root.completedAt !== null && root.completedAt !== undefined) {
+        canonicalTimestamp(root.completedAt, 'Legacy task completedAt');
+    }
+    return root;
+}
+export function runDurableTaskLegacyRootAdoption(input) {
+    if (String(input.baseEntityRevision) !== '0' || String(input.baseLifecycleRevision) !== '0') {
+        throw new TaskLegacyRootAdoptionError('Legacy task root adoption base revisions must both be 0.');
+    }
+    const root = validateTaskLegacyRootAdoptionCandidate(input.adoptedRoot, input.taskId);
+    const identity = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+    };
+    const requestFingerprint = fingerprintWorkspaceSyncPayload({
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        identity,
+        operation: {
+            domain: 'task',
+            entityId: input.taskId,
+            mutationKind: 'create',
+            baseEntityRevision: '0',
+            baseLifecycleRevision: '0',
+            payload: { adoptedRoot: root },
+        },
+    });
+    const existing = input.store.readOperation({ identity, requestFingerprint });
+    if (existing?.state === 'committed') {
+        return {
+            state: 'committed',
+            replayed: true,
+            responseJson: existing.responseJson,
+            response: JSON.parse(existing.responseJson),
+        };
+    }
+    let reservation = input.store.reserveOperation({
+        identity,
+        requestFingerprint,
+        now: input.now,
+        leaseExpiresAt: input.leaseExpiresAt,
+        leaseOwner: input.leaseOwner,
+    });
+    if (reservation.state === 'in_progress')
+        return reservation;
+    if (reservation.state === 'committed') {
+        return {
+            state: 'committed', replayed: true, responseJson: reservation.responseJson,
+            response: JSON.parse(reservation.responseJson),
+        };
+    }
+    assertTaskCreateIdentityAvailable({ core: input.core, workspaceId: input.workspaceId, taskId: input.taskId });
+    const activityEventId = buildTaskCreateActivityEventId({
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+        taskId: input.taskId,
+    });
+    const readActivity = () => {
+        const event = input.core.getTaskEventForSync({
+            workspaceId: input.workspaceId, taskId: input.taskId, eventId: activityEventId,
+        });
+        if (!event)
+            throw new TaskLegacyRootAdoptionError('Legacy task root adoption activity was not committed.');
+        return event;
+    };
+    const accepted = input.store.acceptReservedOperationBatch({
+        identity,
+        requestFingerprint,
+        leaseOwner: reservation.leaseOwner,
+        now: input.now,
+        entries: [{
+                domain: 'task', entityId: input.taskId, mutationKind: 'create', revisionKind: 'metadata',
+                baseEntityRevision: 0, baseLifecycleRevision: 0,
+                buildCanonicalFingerprint: (task) => fingerprintWorkspaceSyncPayload(serializeTaskForSync(task)),
+                buildAuthoritativePayload: (task) => serializeTaskForSync(task),
+            }, buildTaskActivityJournalEntry({ eventId: activityEventId, readEvent: readActivity })],
+        applyMutation: () => {
+            const created = input.core.createTask({
+                ...root,
+                id: input.taskId,
+                referenceNumber: undefined,
+                complexity: root.complexity ?? undefined,
+                createdAt: root.createdAt,
+                updatedAt: root.createdAt,
+            }, {
+                workspaceId: input.workspaceId,
+                allowClientProvidedId: true,
+                persistBackup: false,
+                emitRealtime: false,
+                syncUpdatedAt: root.createdAt,
+                actorRef: input.actorRef,
+                taskEventId: activityEventId,
+                allowV3OwnedCreate: true,
+            });
+            return input.core.installWorkspaceSyncV3TaskRootAuthoritativeForSync({
+                ...root,
+                referenceNumber: created.referenceNumber,
+            }, input.workspaceId);
+        },
+        buildResponse: (task, revisions) => {
+            const taskRevision = revisions[0];
+            const activityRevision = asWorkspaceSyncActivityRevision(revisions[1]);
+            return {
+                success: true,
+                contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+                workspaceId: input.workspaceId,
+                clientId: input.clientId,
+                operationId: input.operationId,
+                provisionalTaskId: input.taskId,
+                adoptedLegacyRoot: true,
+                acceptedSequence: taskRevision.sequence,
+                operationHighWatermark: activityRevision.sequence,
+                authoritative: {
+                    domain: 'task',
+                    entityId: task.id,
+                    mutationKind: 'create',
+                    sequence: taskRevision.sequence,
+                    entityRevision: taskRevision.entityRevision,
+                    lifecycleRevision: taskRevision.lifecycleRevision,
+                    payload: serializeTaskForSync(task),
+                },
+                activity: serializeTaskActivityForSync(readActivity()),
+                activityRevision,
+            };
+        },
+    });
+    const response = JSON.parse(accepted.responseJson);
+    try {
+        input.core.notifyDurableTaskCreateCommitted(input.workspaceId, input.taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* committed adoption remains successful */ }
+    }
+    return { state: 'committed', replayed: false, responseJson: accepted.responseJson, response };
+}

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

@@ -0,0 +1,9 @@
+export type TaskLifecycleActivityMutationKind = 'archive' | 'unarchive' | 'complete' | 'reopen' | 'set-status' | 'restore';
+export declare function isTaskLifecycleActivityEventId(value: unknown): boolean;
+export declare function buildTaskLifecycleActivityEventId(input: {
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    taskId: string;
+    mutationKind: TaskLifecycleActivityMutationKind;
+}): string;

package/dist/sync/v3/taskLifecycleActivityIdentity.js

@@ -0,0 +1,18 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+const TASK_LIFECYCLE_ACTIVITY_EVENT_ID_PATTERN = /^entity-event-sync-v3-[a-f0-9]{64}$/;
+export function isTaskLifecycleActivityEventId(value) {
+    return TASK_LIFECYCLE_ACTIVITY_EVENT_ID_PATTERN.test(String(value || '').trim());
+}
+export function buildTaskLifecycleActivityEventId(input) {
+    const digest = createHash('sha256').update(canonicalWorkspaceSyncJson({
+        contractVersion: 3,
+        domain: 'task',
+        mutationKind: input.mutationKind,
+        workspaceId: String(input.workspaceId || '').trim(),
+        clientId: String(input.clientId || '').trim(),
+        operationId: String(input.operationId || '').trim(),
+        taskId: String(input.taskId || '').trim(),
+    }), 'utf8').digest('hex');
+    return `entity-event-sync-v3-${digest}`;
+}

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

@@ -0,0 +1,5 @@
+import { type DurableTaskLifecycleMutationKind } from '../../core/TaskDurableLifecycleMutationService.js';
+export declare function validateDurableTaskLifecyclePayload(mutationKind: DurableTaskLifecycleMutationKind, value: unknown): {
+    cancellation: boolean;
+    reason: string | null;
+};

package/dist/sync/v3/taskLifecycleMutationPayload.js

@@ -0,0 +1,28 @@
+import { DurableTaskLifecycleMutationError, } from '../../core/TaskDurableLifecycleMutationService.js';
+const MAX_CANCELLATION_REASON_LENGTH = 2000;
+export function validateDurableTaskLifecyclePayload(mutationKind, value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new DurableTaskLifecycleMutationError('Task lifecycle payload must be an object.', 'TASK_LIFECYCLE_INVALID_PAYLOAD', 400);
+    }
+    const record = value;
+    const keys = Object.keys(record).sort();
+    if (mutationKind === 'unarchive') {
+        if (keys.length !== 0)
+            throw new DurableTaskLifecycleMutationError('Unarchive payload must be empty.', 'TASK_LIFECYCLE_INVALID_PAYLOAD', 400);
+        return { cancellation: false, reason: null };
+    }
+    if (keys.length !== 2 || keys[0] !== 'cancellation' || keys[1] !== 'reason' || typeof record.cancellation !== 'boolean') {
+        throw new DurableTaskLifecycleMutationError('Archive payload must contain exactly cancellation and reason.', 'TASK_LIFECYCLE_INVALID_PAYLOAD', 400);
+    }
+    if (record.reason !== null && typeof record.reason !== 'string') {
+        throw new DurableTaskLifecycleMutationError('Archive reason must be a string or null.', 'TASK_LIFECYCLE_INVALID_PAYLOAD', 400);
+    }
+    const reason = typeof record.reason === 'string' ? record.reason.trim() : null;
+    if (reason !== null && (reason.length === 0 || reason.length > MAX_CANCELLATION_REASON_LENGTH)) {
+        throw new DurableTaskLifecycleMutationError(`Archive reason must contain 1-${MAX_CANCELLATION_REASON_LENGTH} characters.`, 'TASK_LIFECYCLE_INVALID_PAYLOAD', 400);
+    }
+    if (!record.cancellation && reason !== null) {
+        throw new DurableTaskLifecycleMutationError('Archive reason must be null when cancellation is false.', 'TASK_LIFECYCLE_INVALID_PAYLOAD', 400);
+    }
+    return { cancellation: record.cancellation, reason };
+}

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

@@ -0,0 +1,66 @@
+import type { TaskEvent } from '../../core/Taskforce.js';
+import { type DurableTaskLifecycleMutationCore, type DurableTaskLifecycleMutationKind } from '../../core/TaskDurableLifecycleMutationService.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+import { type WorkspaceSyncActivityRevision } from './taskActivityJournal.js';
+export { validateDurableTaskLifecyclePayload } from './taskLifecycleMutationPayload.js';
+export type DurableTaskLifecyclePayload = {
+    cancellation: boolean;
+    reason: string | null;
+} | Record<string, never>;
+export interface DurableTaskLifecycleServiceCore extends DurableTaskLifecycleMutationCore {
+    notifyDurableTaskLifecycleCommitted(workspaceId: string, taskId: string): void;
+    getTaskEventForSync(input: {
+        workspaceId: string;
+        taskId: string;
+        eventId: string;
+    }): TaskEvent | null;
+}
+export type DurableTaskLifecycleResponse = {
+    success: true;
+    contractVersion: 3;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    acceptedSequence: string;
+    operationHighWatermark: string;
+    authoritative: {
+        domain: 'task';
+        entityId: string;
+        mutationKind: DurableTaskLifecycleMutationKind;
+        sequence: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        payload: ReturnType<typeof serializeTaskForSync>;
+    };
+    activity: TaskEvent;
+    activityRevision: WorkspaceSyncActivityRevision;
+};
+export declare function runDurableTaskLifecycleMutation(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: DurableTaskLifecycleServiceCore;
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    taskId: string;
+    mutationKind: DurableTaskLifecycleMutationKind;
+    payload: unknown;
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    now: string;
+    leaseExpiresAt: string;
+    leaseOwner?: string;
+    actorRef: string;
+    resolveActorRef?: () => string;
+    originActorRef?: string;
+    onPostCommitError?: (error: unknown) => void;
+}): {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    replayed: boolean;
+    responseJson: string;
+    response: DurableTaskLifecycleResponse;
+};

package/dist/sync/v3/taskLifecycleMutationService.js

@@ -0,0 +1,92 @@
+import { applyTaskLifecycleMutationForDurableSync, DurableTaskLifecycleMutationError, } from '../../core/TaskDurableLifecycleMutationService.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
+import { buildTaskLifecycleActivityEventId } from './taskLifecycleActivityIdentity.js';
+import { asWorkspaceSyncActivityRevision, buildTaskActivityJournalEntry, } from './taskActivityJournal.js';
+import { validateDurableTaskLifecyclePayload } from './taskLifecycleMutationPayload.js';
+import { resolveDeferredMutationActorRef } from './workspaceSyncV3OriginActor.js';
+export { validateDurableTaskLifecyclePayload } from './taskLifecycleMutationPayload.js';
+export function runDurableTaskLifecycleMutation(input) {
+    const payload = validateDurableTaskLifecyclePayload(input.mutationKind, input.payload);
+    const identity = {
+        tenantId: input.tenantId, workspaceId: input.workspaceId, clientId: input.clientId, operationId: input.operationId,
+    };
+    const requestFingerprint = fingerprintWorkspaceSyncPayload({
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        identity,
+        operation: {
+            domain: 'task', entityId: input.taskId, mutationKind: input.mutationKind,
+            baseEntityRevision: String(input.baseEntityRevision), baseLifecycleRevision: String(input.baseLifecycleRevision),
+            payload: input.mutationKind === 'archive' ? payload : {},
+            ...(input.originActorRef ? { originActorRef: input.originActorRef } : {}),
+        },
+    });
+    const activityEventId = buildTaskLifecycleActivityEventId({
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+        taskId: input.taskId,
+        mutationKind: input.mutationKind,
+    });
+    const reservation = input.store.reserveOperation({
+        identity, requestFingerprint, now: input.now, leaseExpiresAt: input.leaseExpiresAt, leaseOwner: input.leaseOwner,
+    });
+    if (reservation.state === 'in_progress')
+        return reservation;
+    if (reservation.state === 'committed')
+        return {
+            state: 'committed', replayed: true, responseJson: reservation.responseJson, response: JSON.parse(reservation.responseJson),
+        };
+    const readActivity = () => {
+        const activity = input.core.getTaskEventForSync({ workspaceId: input.workspaceId, taskId: input.taskId, eventId: activityEventId });
+        if (!activity)
+            throw new DurableTaskLifecycleMutationError('Task lifecycle activity was not committed.', 'TASK_LIFECYCLE_STATE_CONFLICT', 409);
+        return activity;
+    };
+    const accepted = input.store.acceptReservedOperationBatch({
+        identity, requestFingerprint, leaseOwner: reservation.leaseOwner, now: input.now,
+        entries: [{
+                domain: 'task', entityId: input.taskId, mutationKind: input.mutationKind, revisionKind: 'both',
+                baseEntityRevision: input.baseEntityRevision, baseLifecycleRevision: input.baseLifecycleRevision,
+                buildCanonicalFingerprint: (task) => fingerprintWorkspaceSyncPayload(serializeTaskForSync(task)),
+                buildAuthoritativePayload: (task) => serializeTaskForSync(task),
+            }, buildTaskActivityJournalEntry({ eventId: activityEventId, readEvent: readActivity })],
+        applyMutation: () => applyTaskLifecycleMutationForDurableSync({
+            core: input.core, workspaceId: input.workspaceId, taskId: input.taskId, mutationKind: input.mutationKind,
+            cancellation: payload.cancellation, reason: payload.reason, updatedAt: input.now,
+            actorRef: resolveDeferredMutationActorRef(input),
+            taskEventId: activityEventId,
+        }),
+        buildResponse: (task, revisions) => {
+            const taskRevision = revisions[0];
+            const activityRevision = asWorkspaceSyncActivityRevision(revisions[1]);
+            const activity = readActivity();
+            return {
+                success: true, contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION, workspaceId: input.workspaceId,
+                clientId: input.clientId, operationId: input.operationId,
+                acceptedSequence: taskRevision.sequence, operationHighWatermark: activityRevision.sequence,
+                authoritative: {
+                    domain: 'task', entityId: task.id, mutationKind: input.mutationKind,
+                    sequence: taskRevision.sequence,
+                    entityRevision: taskRevision.entityRevision, lifecycleRevision: taskRevision.lifecycleRevision,
+                    payload: serializeTaskForSync(task),
+                },
+                activity,
+                activityRevision,
+            };
+        },
+    });
+    try {
+        input.core.notifyDurableTaskLifecycleCommitted(input.workspaceId, input.taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* accepted mutation remains successful */ }
+    }
+    return {
+        state: 'committed', replayed: false, responseJson: accepted.responseJson,
+        response: JSON.parse(accepted.responseJson),
+    };
+}

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

@@ -0,0 +1,12 @@
+export type TaskMetadataActivationCapability = {
+    taskMetadataActivation: boolean;
+};
+export declare function isTaskMetadataActivationPatch(value: unknown): boolean;
+/**
+ * Resolves the single browser-facing activation capability without exposing
+ * individual server feature flags or environment values.
+ */
+export declare function resolveTaskMetadataActivationCapability(input: {
+    runtimeMode: 'local' | 'cloud';
+    env?: NodeJS.ProcessEnv;
+}): TaskMetadataActivationCapability;

package/dist/sync/v3/taskMetadataActivation.js

@@ -0,0 +1,38 @@
+const TASK_METADATA_ACTIVATION_FIELDS = new Set([
+    'title',
+    'description',
+    'priority',
+    'complexity',
+    'type',
+    'category',
+    'assignee',
+    'scheduledDate',
+    'dueDate',
+    'scheduledWeekKey',
+    'orderInDay',
+    'workstreamId',
+    'taxonomies',
+]);
+function isEnabled(value) {
+    return /^(1|true|on|yes)$/i.test(String(value || '').trim());
+}
+export function isTaskMetadataActivationPatch(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const keys = Object.keys(value);
+    return keys.length > 0 && keys.every((key) => TASK_METADATA_ACTIVATION_FIELDS.has(key));
+}
+/**
+ * Resolves the single browser-facing activation capability without exposing
+ * individual server feature flags or environment values.
+ */
+export function resolveTaskMetadataActivationCapability(input) {
+    const env = input.env || process.env;
+    return {
+        taskMetadataActivation: input.runtimeMode === 'local'
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASK_METADATA_ACTIVATION_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASKS_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_LOCAL_CAPTURE_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_LOCAL_DISPATCH_ENABLED),
+    };
+}

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

@@ -0,0 +1,7 @@
+export declare function isTaskMetadataActivityEventId(value: unknown): boolean;
+export declare function buildTaskMetadataActivityEventId(input: {
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    taskId: string;
+}): string;