@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/v3/taskMetadataActivityIdentity.js

@@ -0,0 +1,18 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+const TASK_METADATA_ACTIVITY_EVENT_ID_PATTERN = /^entity-event-sync-v3-[a-f0-9]{64}$/;
+export function isTaskMetadataActivityEventId(value) {
+    return TASK_METADATA_ACTIVITY_EVENT_ID_PATTERN.test(String(value || '').trim());
+}
+export function buildTaskMetadataActivityEventId(input) {
+    const digest = createHash('sha256').update(canonicalWorkspaceSyncJson({
+        contractVersion: 3,
+        domain: 'task',
+        mutationKind: 'metadata-update',
+        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/taskMetadataCoexistence.d.ts

@@ -0,0 +1,37 @@
+import type { TaskItem } from '../../core/Taskforce.js';
+import type { WorkspaceSyncTaskSnapshot } from '../workspaceSyncModel.js';
+import type { WorkspaceSyncTaskMetadataOwnership } from './syncDurabilityStore.js';
+export type TaskMetadataCoexistenceDirection = 'cloud-push' | 'local-pull';
+export declare function resolveV3OwnedTaskMetadataIds(input: {
+    direction: TaskMetadataCoexistenceDirection;
+    ownership: WorkspaceSyncTaskMetadataOwnership[];
+    assertedActiveTaskIds?: ReadonlySet<string>;
+}): Set<string>;
+export declare function resolveV3OwnedTaskDeleteIds(input: {
+    direction: TaskMetadataCoexistenceDirection;
+    ownership: WorkspaceSyncTaskMetadataOwnership[];
+    assertedActiveTaskIds?: ReadonlySet<string>;
+}): Set<string>;
+export declare function preserveV3OwnedTaskMetadata(incoming: WorkspaceSyncTaskSnapshot, existing: TaskItem): WorkspaceSyncTaskSnapshot;
+export declare function preserveV3OwnedTaskRoot(incoming: WorkspaceSyncTaskSnapshot, existing: TaskItem): WorkspaceSyncTaskSnapshot;
+export declare function resolveV3OwnedTaskTaxonomyIds(input: {
+    direction: TaskMetadataCoexistenceDirection;
+    ownership: Array<{
+        taskId: string;
+        activeOperation: boolean;
+        owned: boolean;
+    }>;
+}): Set<string>;
+export declare function preserveV3OwnedTaskTaxonomy(incoming: WorkspaceSyncTaskSnapshot, existing: TaskItem): WorkspaceSyncTaskSnapshot;
+export declare function resolveV3OwnedTaskLifecycleIds(input: {
+    direction: TaskMetadataCoexistenceDirection;
+    ownership: WorkspaceSyncTaskMetadataOwnership[];
+    assertedActiveTaskIds?: ReadonlySet<string>;
+}): Set<string>;
+export declare function preserveV3OwnedTaskLifecycle(incoming: WorkspaceSyncTaskSnapshot, existing: TaskItem): WorkspaceSyncTaskSnapshot;
+export declare function resolveV3OwnedTaskReopenAssigneeIds(input: {
+    direction: TaskMetadataCoexistenceDirection;
+    ownership: WorkspaceSyncTaskMetadataOwnership[];
+    assertedActiveTaskIds?: ReadonlySet<string>;
+}): Set<string>;
+export declare function preserveV3OwnedTaskReopenAssignee(incoming: WorkspaceSyncTaskSnapshot, existing: TaskItem): WorkspaceSyncTaskSnapshot;

package/dist/sync/v3/taskMetadataCoexistence.js

@@ -0,0 +1,134 @@
+import { DURABLE_TASK_METADATA_FIELDS } from '../../core/TaskDurableSyncMutationService.js';
+import { serializeTaskRootForSync } from './workspaceSyncV3TaskRootProjection.js';
+function isPositiveRevision(value) {
+    if (value === null || !/^\d+$/.test(value))
+        return false;
+    return BigInt(value) > 0n;
+}
+function withoutRetiredApproach(snapshot) {
+    const { approach: _approach, ...current } = snapshot;
+    if (!current.taxonomies || typeof current.taxonomies !== 'object' || Array.isArray(current.taxonomies)) {
+        return current;
+    }
+    const { approach: _taxonomyApproach, ...taxonomies } = current.taxonomies;
+    return { ...current, taxonomies };
+}
+export function resolveV3OwnedTaskMetadataIds(input) {
+    const owned = new Set();
+    for (const entry of input.ownership) {
+        const taskId = String(entry.taskId || '').trim();
+        if (!taskId)
+            continue;
+        const protectsMetadata = input.direction === 'cloud-push'
+            ? entry.metadataOwned === true || Boolean(input.assertedActiveTaskIds?.has(taskId))
+            : entry.activeOperation;
+        if (protectsMetadata)
+            owned.add(taskId);
+    }
+    if (input.direction === 'cloud-push') {
+        for (const taskId of input.assertedActiveTaskIds || []) {
+            const normalized = String(taskId || '').trim();
+            if (normalized)
+                owned.add(normalized);
+        }
+    }
+    return owned;
+}
+export function resolveV3OwnedTaskDeleteIds(input) {
+    const owned = new Set();
+    for (const entry of input.ownership) {
+        const taskId = String(entry.taskId || '').trim();
+        if (!taskId)
+            continue;
+        if (entry.deleteOwned === true
+            || entry.activeDeleteOperation === true
+            || (input.direction === 'cloud-push' && input.assertedActiveTaskIds?.has(taskId))) {
+            owned.add(taskId);
+        }
+    }
+    return owned;
+}
+export function preserveV3OwnedTaskMetadata(incoming, existing) {
+    const merged = withoutRetiredApproach(incoming);
+    const current = existing;
+    for (const field of DURABLE_TASK_METADATA_FIELDS) {
+        merged[field] = current[field];
+    }
+    return merged;
+}
+export function preserveV3OwnedTaskRoot(incoming, existing) {
+    return {
+        ...serializeTaskRootForSync(existing),
+        comments: incoming.comments ?? existing.comments,
+        attachments: incoming.attachments ?? existing.attachments,
+        checklistItems: incoming.checklistItems ?? existing.checklistItems,
+    };
+}
+export function resolveV3OwnedTaskTaxonomyIds(input) {
+    return new Set(input.ownership
+        .filter((entry) => entry.owned || entry.activeOperation)
+        .map((entry) => String(entry.taskId || '').trim())
+        .filter(Boolean));
+}
+export function preserveV3OwnedTaskTaxonomy(incoming, existing) {
+    return {
+        ...withoutRetiredApproach(incoming),
+        category: existing.category,
+        type: existing.type,
+        priority: existing.priority,
+    };
+}
+export function resolveV3OwnedTaskLifecycleIds(input) {
+    const owned = new Set();
+    for (const entry of input.ownership) {
+        const taskId = String(entry.taskId || '').trim();
+        if (!taskId)
+            continue;
+        const protectsLifecycle = input.direction === 'cloud-push'
+            ? isPositiveRevision(entry.lifecycleRevision) || Boolean(input.assertedActiveTaskIds?.has(taskId))
+            : entry.activeLifecycleOperation === true;
+        if (protectsLifecycle)
+            owned.add(taskId);
+    }
+    if (input.direction === 'cloud-push') {
+        for (const taskId of input.assertedActiveTaskIds || []) {
+            const normalized = String(taskId || '').trim();
+            if (normalized)
+                owned.add(normalized);
+        }
+    }
+    return owned;
+}
+export function preserveV3OwnedTaskLifecycle(incoming, existing) {
+    return {
+        ...withoutRetiredApproach(incoming),
+        status: existing.status,
+        isArchived: Boolean(existing.isArchived),
+        completedAt: existing.completedAt ?? null,
+        canceledReason: existing.canceledReason ?? null,
+    };
+}
+export function resolveV3OwnedTaskReopenAssigneeIds(input) {
+    const owned = new Set();
+    for (const entry of input.ownership) {
+        const taskId = String(entry.taskId || '').trim();
+        if (!taskId)
+            continue;
+        const protectsAssignee = entry.reopenAssigneeOwned === true
+            || entry.activeReopenOperation === true
+            || (input.direction === 'cloud-push' && Boolean(input.assertedActiveTaskIds?.has(taskId)));
+        if (protectsAssignee)
+            owned.add(taskId);
+    }
+    if (input.direction === 'cloud-push') {
+        for (const taskId of input.assertedActiveTaskIds || []) {
+            const normalized = String(taskId || '').trim();
+            if (normalized)
+                owned.add(normalized);
+        }
+    }
+    return owned;
+}
+export function preserveV3OwnedTaskReopenAssignee(incoming, existing) {
+    return { ...withoutRetiredApproach(incoming), assignee: existing.assignee };
+}

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

@@ -0,0 +1,71 @@
+import type { EntityEvent, TaskEvent, TaskItem } from '../../core/Taskforce.js';
+import { type DurableTaskMetadataMutationCore } from '../../core/TaskDurableSyncMutationService.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { serializeTaskActivityForSync, type WorkspaceSyncActivityRevision } from './taskActivityJournal.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+export type DurableTaskMetadataResponse = {
+    success: true;
+    contractVersion: 3;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    acceptedSequence: string;
+    operationHighWatermark: string;
+    authoritative: {
+        domain: 'task';
+        entityId: string;
+        mutationKind: 'metadata-update';
+        sequence: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        payload: ReturnType<typeof serializeTaskForSync>;
+    };
+    activity: ReturnType<typeof serializeTaskActivityForSync>;
+    activityRevision: WorkspaceSyncActivityRevision;
+    dependentActivities?: EntityEvent[];
+    dependentActivityRevisions?: WorkspaceSyncActivityRevision[];
+};
+export type DurableTaskMetadataMutationResult = {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    replayed: boolean;
+    responseJson: string;
+    response: DurableTaskMetadataResponse;
+};
+export interface DurableTaskMetadataServiceCore extends DurableTaskMetadataMutationCore {
+    notifyDurableTaskMetadataCommitted(workspaceId: string, taskId: string): void;
+    getTaskEventForSync(input: {
+        workspaceId: string;
+        taskId: string;
+        eventId: string;
+    }): TaskEvent | null;
+    getEntityEventForSync(input: {
+        workspaceId: string;
+        eventId: string;
+    }): EntityEvent | null;
+}
+export declare function runDurableTaskMetadataUpdate(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: DurableTaskMetadataServiceCore;
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    taskId: string;
+    patch: Partial<TaskItem>;
+    carriers?: Partial<Pick<TaskItem, 'attachments' | 'checklistItems' | 'comments'>>;
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    now: string;
+    leaseExpiresAt: string;
+    leaseOwner?: string;
+    actorRef: string;
+    /** Deferred origin resolution — invoke only after committed replay short-circuit. */
+    resolveActorRef?: () => string;
+    originActorRef?: string;
+    saveSource?: 'manual' | 'autosave';
+    activityAction?: 'task-updated' | 'task-schedule-changed';
+    onPostCommitError?: (error: unknown) => void;
+}): DurableTaskMetadataMutationResult;

package/dist/sync/v3/taskMetadataMutationService.js

@@ -0,0 +1,199 @@
+import { applyTaskMetadataUpdateForDurableSync, DurableTaskMetadataMutationError, validateDurableTaskMetadataPatch, } from '../../core/TaskDurableSyncMutationService.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { buildTaskMetadataActivityEventId } from './taskMetadataActivityIdentity.js';
+import { asWorkspaceSyncActivityRevision, buildEntityActivityJournalEntry, buildTaskActivityJournalEntry, serializeTaskActivityForSync, } from './taskActivityJournal.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
+import { resolveDeferredMutationActorRef } from './workspaceSyncV3OriginActor.js';
+export function runDurableTaskMetadataUpdate(input) {
+    const hasMetadataPatch = Boolean(input.patch && Object.keys(input.patch).length > 0);
+    const validatedPatch = hasMetadataPatch ? validateDurableTaskMetadataPatch(input.patch) : {};
+    const carriers = input.carriers;
+    if (carriers && (Object.keys(carriers).length === 0 || Object.values(carriers).some((value) => !Array.isArray(value)))) {
+        throw new DurableTaskMetadataMutationError('Task carrier patch must contain arrays.', 'DURABLE_TASK_PATCH_INVALID', 400);
+    }
+    if (!hasMetadataPatch && !carriers) {
+        throw new DurableTaskMetadataMutationError('Task metadata patch cannot be empty.', 'DURABLE_TASK_PATCH_INVALID', 400);
+    }
+    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: 'metadata-update',
+            baseEntityRevision: String(input.baseEntityRevision),
+            baseLifecycleRevision: String(input.baseLifecycleRevision),
+            patch: validatedPatch,
+            ...(carriers ? { carriers } : {}),
+            ...(input.originActorRef ? { originActorRef: input.originActorRef } : {}),
+            ...(input.activityAction && input.activityAction !== 'task-updated'
+                ? { activityAction: input.activityAction }
+                : {}),
+        },
+    });
+    const activityEventId = buildTaskMetadataActivityEventId({
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+        taskId: input.taskId,
+    });
+    const membershipRemovedEventId = `${activityEventId}:workstream-removed`;
+    const membershipAddedEventId = `${activityEventId}:workstream-added`;
+    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 Error('Durable task metadata activity was not persisted.');
+        return activity;
+    };
+    const accepted = input.store.acceptReservedOperationBatch({
+        identity,
+        requestFingerprint,
+        leaseOwner: reservation.leaseOwner,
+        now: input.now,
+        entries: [{
+                domain: 'task',
+                entityId: input.taskId,
+                mutationKind: 'metadata-update',
+                revisionKind: 'metadata',
+                baseEntityRevision: input.baseEntityRevision,
+                baseLifecycleRevision: input.baseLifecycleRevision,
+                buildCanonicalFingerprint: (task) => fingerprintWorkspaceSyncPayload(serializeTaskForSync(task)),
+                buildAuthoritativePayload: (task) => serializeTaskForSync(task),
+            }, buildTaskActivityJournalEntry({ eventId: activityEventId, readEvent: readActivity }), {
+                ...buildEntityActivityJournalEntry({
+                    eventId: membershipRemovedEventId,
+                    readEvent: () => input.core.getEntityEventForSync({
+                        workspaceId: input.workspaceId,
+                        eventId: membershipRemovedEventId,
+                    }),
+                }),
+                include: () => Boolean(input.core.getEntityEventForSync({
+                    workspaceId: input.workspaceId,
+                    eventId: membershipRemovedEventId,
+                })),
+            }, {
+                ...buildEntityActivityJournalEntry({
+                    eventId: membershipAddedEventId,
+                    readEvent: () => input.core.getEntityEventForSync({
+                        workspaceId: input.workspaceId,
+                        eventId: membershipAddedEventId,
+                    }),
+                }),
+                include: () => Boolean(input.core.getEntityEventForSync({
+                    workspaceId: input.workspaceId,
+                    eventId: membershipAddedEventId,
+                })),
+            }],
+        applyMutation: () => {
+            const actorRef = resolveDeferredMutationActorRef(input);
+            if (!carriers)
+                return applyTaskMetadataUpdateForDurableSync({
+                    core: input.core,
+                    workspaceId: input.workspaceId,
+                    taskId: input.taskId,
+                    patch: validatedPatch,
+                    updatedAt: input.now,
+                    actorRef,
+                    activityEventId,
+                    saveSource: input.saveSource,
+                    activityAction: input.activityAction,
+                });
+            const updated = input.core.updateTask(input.taskId, {
+                ...validatedPatch,
+                ...carriers,
+            }, input.workspaceId, {
+                persistBackup: false,
+                taskEventId: activityEventId,
+                allowAuthoritativeTaskEventReplacement: true,
+                ...(hasMetadataPatch ? { taskEventAction: input.activityAction || 'task-updated' } : {}),
+                syncUpdatedAt: input.now,
+                actorRef,
+                saveSource: input.saveSource,
+                emitRealtime: false,
+                allowV3OwnedMetadataWrite: true,
+            });
+            if (!updated)
+                throw new DurableTaskMetadataMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+            return updated;
+        },
+        buildResponse: (task, revisions) => {
+            const taskRevision = revisions[0];
+            const activityRevision = asWorkspaceSyncActivityRevision(revisions[1]);
+            const dependentActivityRevisions = revisions.slice(2).map(asWorkspaceSyncActivityRevision);
+            const dependentActivities = dependentActivityRevisions.map((revision) => {
+                const event = input.core.getEntityEventForSync({ workspaceId: input.workspaceId, eventId: revision.entityId });
+                if (!event)
+                    throw new Error('Dependent task metadata activity was not committed.');
+                return event;
+            });
+            const activity = readActivity();
+            return {
+                success: true,
+                contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+                workspaceId: input.workspaceId,
+                clientId: input.clientId,
+                operationId: input.operationId,
+                // Preserve the existing single-entity field for rolling clients.
+                acceptedSequence: taskRevision.sequence,
+                operationHighWatermark: revisions.at(-1)?.sequence || activityRevision.sequence,
+                authoritative: {
+                    domain: 'task',
+                    entityId: task.id,
+                    mutationKind: 'metadata-update',
+                    sequence: taskRevision.sequence,
+                    entityRevision: taskRevision.entityRevision,
+                    lifecycleRevision: taskRevision.lifecycleRevision,
+                    payload: serializeTaskForSync(task),
+                },
+                activity: serializeTaskActivityForSync(activity),
+                activityRevision,
+                ...(dependentActivities.length > 0 ? { dependentActivities } : {}),
+                ...(dependentActivityRevisions.length > 0 ? { dependentActivityRevisions } : {}),
+            };
+        },
+    });
+    try {
+        input.core.notifyDurableTaskMetadataCommitted(input.workspaceId, input.taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch {
+            // A diagnostic failure cannot turn an accepted durable mutation into a failed response.
+        }
+    }
+    return {
+        state: 'committed',
+        replayed: false,
+        responseJson: accepted.responseJson,
+        response: JSON.parse(accepted.responseJson),
+    };
+}

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

@@ -0,0 +1,48 @@
+import type { TaskRelationshipInputType, TaskRelationshipRecord } from '../../core/Taskforce.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+import type { DurableTaskRelationshipResponse } from './taskRelationshipMutationService.js';
+export interface TaskRelationshipLegacyAdoptionCore {
+    resolveTaskRelationshipIdentity(sourceTaskId: string, targetTaskId: string, type: TaskRelationshipInputType, workspaceId?: string): {
+        id: string;
+        sourceTaskId: string;
+        targetTaskId: string;
+        kind: string;
+    };
+    getTaskRelationshipForSync(id: string, workspaceId?: string): TaskRelationshipRecord | null;
+    installDurableTaskRelationshipAuthoritativeForSync(relationship: TaskRelationshipRecord, workspaceId?: string): 'applied';
+    notifyDurableTaskRelationshipCommitted(workspaceId: string, relationship: TaskRelationshipRecord, changeType: 'upsert' | 'delete'): void;
+}
+export declare class TaskRelationshipLegacyAdoptionError extends Error {
+    readonly code = "WORKSPACE_SYNC_LEGACY_RELATIONSHIP_ADOPTION_INVALID";
+    readonly statusCode = 409;
+    constructor(message: string);
+}
+export declare function validateTaskRelationshipLegacyAdoptionCandidate(input: {
+    core: TaskRelationshipLegacyAdoptionCore;
+    workspaceId: string;
+    relationship: TaskRelationshipRecord;
+}): TaskRelationshipRecord;
+export declare function runDurableTaskRelationshipLegacyAdoption(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: TaskRelationshipLegacyAdoptionCore;
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    adoptedRelationship: TaskRelationshipRecord;
+    mutationKind: 'link' | 'unlink';
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    now: string;
+    leaseExpiresAt: string;
+    leaseOwner?: string;
+    onPostCommitError?: (error: unknown) => void;
+}): {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    replayed: boolean;
+    responseJson: string;
+    response: DurableTaskRelationshipResponse;
+};

package/dist/sync/v3/taskRelationshipLegacyAdoptionService.js

@@ -0,0 +1,164 @@
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, WorkspaceSyncRevisionConflictError, } from './syncDurabilityStore.js';
+export class TaskRelationshipLegacyAdoptionError extends Error {
+    code = 'WORKSPACE_SYNC_LEGACY_RELATIONSHIP_ADOPTION_INVALID';
+    statusCode = 409;
+    constructor(message) {
+        super(message);
+        this.name = 'TaskRelationshipLegacyAdoptionError';
+    }
+}
+function canonicalIso(value, label) {
+    const text = String(value || '').trim();
+    if (!text || !Number.isFinite(Date.parse(text)) || new Date(text).toISOString() !== text) {
+        throw new TaskRelationshipLegacyAdoptionError(`${label} is invalid.`);
+    }
+    return text;
+}
+export function validateTaskRelationshipLegacyAdoptionCandidate(input) {
+    const relationship = input.relationship;
+    if (!relationship
+        || typeof relationship.id !== 'string'
+        || relationship.workspaceId !== input.workspaceId
+        || typeof relationship.sourceTaskId !== 'string'
+        || typeof relationship.targetTaskId !== 'string'
+        || !['dependency', 'related', 'supersedes'].includes(relationship.kind)
+        || !['createdBy', 'updatedBy', 'deletedBy'].every((field) => {
+            const value = relationship[field];
+            return value === null || typeof value === 'string';
+        })
+        || (relationship.deletedAt !== null && typeof relationship.deletedAt !== 'string')) {
+        throw new TaskRelationshipLegacyAdoptionError('Legacy relationship workspace identity is invalid.');
+    }
+    const type = relationship.kind === 'dependency'
+        ? 'depends_on'
+        : relationship.kind === 'related'
+            ? 'related_to'
+            : 'supersedes';
+    const resolved = input.core.resolveTaskRelationshipIdentity(relationship.sourceTaskId, relationship.targetTaskId, type, input.workspaceId);
+    if (resolved.id !== relationship.id || resolved.kind !== relationship.kind) {
+        throw new TaskRelationshipLegacyAdoptionError('Legacy relationship identity is not canonical.');
+    }
+    canonicalIso(relationship.createdAt, 'Legacy relationship createdAt');
+    canonicalIso(relationship.updatedAt, 'Legacy relationship updatedAt');
+    if (relationship.deletedAt !== null) {
+        canonicalIso(relationship.deletedAt, 'Legacy relationship deletedAt');
+    }
+    return relationship;
+}
+export function runDurableTaskRelationshipLegacyAdoption(input) {
+    if (String(input.baseEntityRevision) !== '0' || String(input.baseLifecycleRevision) !== '0') {
+        throw new TaskRelationshipLegacyAdoptionError('Legacy relationship adoption base revisions must both be 0.');
+    }
+    const relationship = validateTaskRelationshipLegacyAdoptionCandidate({
+        core: input.core,
+        workspaceId: input.workspaceId,
+        relationship: input.adoptedRelationship,
+    });
+    const expectedMutationKind = relationship.deletedAt ? 'unlink' : 'link';
+    if (input.mutationKind !== expectedMutationKind) {
+        throw new TaskRelationshipLegacyAdoptionError('Legacy relationship adoption mutation kind does not match its lifecycle state.');
+    }
+    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-relationship',
+            entityId: relationship.id,
+            mutationKind: input.mutationKind,
+            baseEntityRevision: '0',
+            baseLifecycleRevision: '0',
+            adoptedRelationship: relationship,
+        },
+    });
+    const existingOperation = input.store.readOperation({ identity, requestFingerprint });
+    if (existingOperation?.state === 'committed') {
+        return {
+            state: 'committed',
+            replayed: true,
+            responseJson: existingOperation.responseJson,
+            response: JSON.parse(existingOperation.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),
+        };
+    }
+    const current = input.core.getTaskRelationshipForSync(relationship.id, input.workspaceId);
+    if (current && fingerprintWorkspaceSyncPayload(current) !== fingerprintWorkspaceSyncPayload(relationship)) {
+        throw new WorkspaceSyncRevisionConflictError({
+            stage: 'legacy-relationship-adoption-conflict',
+            domain: 'task-relationship',
+            entityId: relationship.id,
+        });
+    }
+    const mutationKind = input.mutationKind;
+    const accepted = input.store.acceptReservedOperation({
+        identity,
+        requestFingerprint,
+        leaseOwner: reservation.leaseOwner,
+        now: input.now,
+        domain: 'task-relationship',
+        entityId: relationship.id,
+        mutationKind,
+        revisionKind: relationship.deletedAt ? 'both' : 'metadata',
+        baseEntityRevision: 0,
+        baseLifecycleRevision: 0,
+        applyMutation: () => {
+            input.core.installDurableTaskRelationshipAuthoritativeForSync(relationship, input.workspaceId);
+            return relationship;
+        },
+        buildCanonicalFingerprint: (value) => fingerprintWorkspaceSyncPayload(value),
+        buildAuthoritativePayload: (value) => value,
+        buildResponse: (value, revision) => ({
+            success: true,
+            contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+            workspaceId: input.workspaceId,
+            clientId: input.clientId,
+            operationId: input.operationId,
+            acceptedSequence: revision.sequence,
+            authoritative: {
+                domain: 'task-relationship',
+                entityId: value.id,
+                mutationKind,
+                entityRevision: revision.entityRevision,
+                lifecycleRevision: revision.lifecycleRevision,
+                payload: value,
+            },
+        }),
+    });
+    const response = JSON.parse(accepted.responseJson);
+    try {
+        input.core.notifyDurableTaskRelationshipCommitted(input.workspaceId, relationship, mutationKind === 'unlink' ? 'delete' : 'upsert');
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* accepted adoption remains committed */ }
+    }
+    return {
+        state: 'committed',
+        replayed: false,
+        responseJson: accepted.responseJson,
+        response,
+    };
+}