@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/core/TaskChecklistCommandService.js

@@ -0,0 +1,111 @@
+export class TaskChecklistCommandError extends Error {
+    code;
+    statusCode;
+    details;
+    constructor(message, code = 'TASK_CHECKLIST_INVALID_ARGUMENT', statusCode = 400, details) {
+        super(message);
+        this.name = 'TaskChecklistCommandError';
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+    }
+}
+function normalizeTitle(value, context) {
+    const title = String(value ?? '').trim();
+    if (!title) {
+        throw new TaskChecklistCommandError(`${context} requires non-empty text.`);
+    }
+    if (/^checklist item\s+\d+$/i.test(title)) {
+        throw new TaskChecklistCommandError(`${context} requires descriptive text, not a placeholder like "${title}".`);
+    }
+    return title;
+}
+function requireMutationResult(task, taskId) {
+    if (task)
+        return;
+    throw new TaskChecklistCommandError(`Task ${taskId} not found`, 'TASK_NOT_FOUND', 404, { taskId });
+}
+export function createTaskChecklistCommandService(deps) {
+    const replaceItems = (taskId, items, operationKey) => {
+        requireMutationResult(deps.replace({
+            taskId,
+            items,
+            operationId: deps.createId('operation', operationKey),
+        }), taskId);
+        return deps.listItems(taskId);
+    };
+    return {
+        replace(input) {
+            const task = deps.resolveTask(input.taskId);
+            if (!Array.isArray(input.items)) {
+                throw new TaskChecklistCommandError('replace_task_checklist requires an items array.');
+            }
+            const now = deps.now();
+            const existingById = new Map(deps.listItems(task.id).map((item) => [item.id, item]));
+            const checklistItems = input.items.map((raw, index) => {
+                const candidate = raw && typeof raw === 'object'
+                    ? raw
+                    : {};
+                const title = normalizeTitle(candidate.title ?? candidate.text, `replace_task_checklist item ${index + 1}`);
+                const id = String(candidate.id || deps.createId('checklist', `replace:${task.id}:${index}`));
+                const existing = existingById.get(id);
+                const isCompleted = Boolean(candidate.isCompleted ?? candidate.done);
+                const order = Number.isFinite(Number(candidate.order)) ? Number(candidate.order) : index;
+                const unchanged = existing
+                    && existing.title === title
+                    && existing.isCompleted === isCompleted
+                    && existing.order === order;
+                const createdAt = String(existing?.createdAt || candidate.createdAt || now);
+                return {
+                    id,
+                    taskId: task.id,
+                    title,
+                    isCompleted,
+                    order,
+                    createdAt,
+                    updatedAt: String(unchanged
+                        ? existing.updatedAt
+                        : existing
+                            ? now
+                            : candidate.updatedAt || createdAt),
+                };
+            });
+            return {
+                taskId: task.id,
+                items: replaceItems(task.id, checklistItems, `task-checklist-replace:${task.id}`),
+            };
+        },
+        add(input) {
+            const task = deps.resolveTask(input.taskId);
+            const title = normalizeTitle(input.title ?? input.text, 'add_task_checklist_item text');
+            const now = deps.now();
+            const currentItems = deps.listItems(task.id);
+            const itemId = deps.createId('checklist', `add:${task.id}`);
+            const existingItem = currentItems.find((item) => item.id === itemId);
+            const requestedCompleted = Boolean(input.isCompleted ?? input.done);
+            const nextItem = existingItem
+                && existingItem.title === title
+                && existingItem.isCompleted === requestedCompleted
+                ? existingItem
+                : {
+                    id: itemId,
+                    taskId: task.id,
+                    title,
+                    isCompleted: requestedCompleted,
+                    order: existingItem?.order ?? currentItems.length,
+                    createdAt: existingItem?.createdAt || now,
+                    updatedAt: now,
+                };
+            const nextItems = [
+                ...currentItems.filter((item) => item.id !== itemId),
+                nextItem,
+            ];
+            const items = replaceItems(task.id, nextItems, `task-checklist-add:${task.id}`);
+            return {
+                taskId: task.id,
+                item: items[items.length - 1] || null,
+                items,
+            };
+        },
+    };
+}

package/dist/core/TaskDurableCreateMutationService.d.ts

@@ -0,0 +1,38 @@
+import type { TaskItem } from './Taskforce.js';
+export declare class DurableTaskCreateMutationError extends Error {
+    readonly code: 'TASK_CREATE_INVALID' | 'TASK_CREATE_ID_CONFLICT' | 'TASK_CREATE_TOMBSTONE_CONFLICT' | 'TASK_CREATE_FAILED';
+    readonly statusCode: number;
+    constructor(message: string, code: 'TASK_CREATE_INVALID' | 'TASK_CREATE_ID_CONFLICT' | 'TASK_CREATE_TOMBSTONE_CONFLICT' | 'TASK_CREATE_FAILED', statusCode: number);
+}
+export interface DurableTaskCreateMutationCore {
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    hasTaskDeletionMarkerForSync(id: string, workspaceId?: string): boolean;
+    createTask(input: Partial<TaskItem>, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        workspaceId?: string;
+        allowClientProvidedId?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        taskEventId?: string;
+        durableProvisionalCreate?: boolean;
+        allowV3OwnedCreate?: boolean;
+        preferExplicitAttachmentAssetId?: boolean;
+    }): TaskItem;
+}
+export declare function validateDurableTaskCreateInput(value: unknown): Partial<TaskItem>;
+export declare function assertTaskCreateIdentityAvailable(input: {
+    core: DurableTaskCreateMutationCore;
+    workspaceId: string;
+    taskId: string;
+}): void;
+export declare function applyTaskCreateForDurableSync(input: {
+    core: DurableTaskCreateMutationCore;
+    workspaceId: string;
+    taskId: string;
+    task: Partial<TaskItem>;
+    carriers?: Pick<TaskItem, 'attachments' | 'checklistItems' | 'comments'>;
+    now: string;
+    actorRef: string;
+    activityEventId?: string;
+}): TaskItem;

package/dist/core/TaskDurableCreateMutationService.js

@@ -0,0 +1,85 @@
+const DURABLE_TASK_CREATE_FIELDS = new Set([
+    'title',
+    'description',
+    'priority',
+    'complexity',
+    'type',
+    'category',
+    'assignee',
+    'status',
+    'scheduledDate',
+    'dueDate',
+    'orderInDay',
+    'workstreamId',
+    'taxonomies',
+]);
+const DURABLE_TASK_CREATE_STATUSES = new Set([
+    'task',
+    'on-hold',
+    'in-progress',
+    'review',
+    'done',
+    'cancelled',
+]);
+export class DurableTaskCreateMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskCreateMutationError';
+    }
+}
+export function validateDurableTaskCreateInput(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new DurableTaskCreateMutationError('Task create input must be an object.', 'TASK_CREATE_INVALID', 400);
+    }
+    const source = value;
+    for (const key of Object.keys(source)) {
+        if (!DURABLE_TASK_CREATE_FIELDS.has(key)) {
+            throw new DurableTaskCreateMutationError(`Task create field is not supported by this contract: ${key}`, 'TASK_CREATE_INVALID', 400);
+        }
+    }
+    const title = typeof source.title === 'string' ? source.title.trim() : '';
+    if (!title) {
+        throw new DurableTaskCreateMutationError('Task title is required.', 'TASK_CREATE_INVALID', 400);
+    }
+    if (source.status !== undefined && !DURABLE_TASK_CREATE_STATUSES.has(source.status)) {
+        throw new DurableTaskCreateMutationError(`Task create status is not supported by this contract: ${String(source.status)}`, 'TASK_CREATE_INVALID', 400);
+    }
+    return { ...source, title };
+}
+export function assertTaskCreateIdentityAvailable(input) {
+    if (input.core.getTask(input.taskId, input.workspaceId)) {
+        throw new DurableTaskCreateMutationError('Task id already exists.', 'TASK_CREATE_ID_CONFLICT', 409);
+    }
+    if (input.core.hasTaskDeletionMarkerForSync(input.taskId, input.workspaceId)) {
+        throw new DurableTaskCreateMutationError('Task id has a retained deletion marker and cannot be recreated.', 'TASK_CREATE_TOMBSTONE_CONFLICT', 409);
+    }
+}
+export function applyTaskCreateForDurableSync(input) {
+    assertTaskCreateIdentityAvailable(input);
+    const created = input.core.createTask({
+        ...input.task,
+        ...(input.carriers || {}),
+        id: input.taskId,
+        createdAt: input.now,
+        updatedAt: input.now,
+        createdBy: input.actorRef,
+    }, {
+        workspaceId: input.workspaceId,
+        allowClientProvidedId: true,
+        persistBackup: false,
+        emitRealtime: false,
+        syncUpdatedAt: input.now,
+        actorRef: input.actorRef,
+        taskEventId: input.activityEventId,
+        allowV3OwnedCreate: true,
+        preferExplicitAttachmentAssetId: true,
+    });
+    if (!created || created.id !== input.taskId || !created.referenceNumber || created.localReferenceNumber) {
+        throw new DurableTaskCreateMutationError('Task creation did not produce a canonical task identity.', 'TASK_CREATE_FAILED', 500);
+    }
+    return created;
+}

package/dist/core/TaskDurableDeleteMutationService.d.ts

@@ -0,0 +1,47 @@
+import type { TaskItem, TaskRelationshipRecord } from './Taskforce.js';
+export declare class DurableTaskDeleteMutationError extends Error {
+    readonly code: 'TASK_NOT_FOUND' | 'TASK_DELETE_RELATIONSHIP_SET_CHANGED' | 'TASK_DELETE_FAILED';
+    readonly statusCode: number;
+    constructor(message: string, code: 'TASK_NOT_FOUND' | 'TASK_DELETE_RELATIONSHIP_SET_CHANGED' | 'TASK_DELETE_FAILED', statusCode: number);
+}
+export interface DurableTaskDeleteCore {
+    lockTaskRelationshipMutationDomain(workspaceId?: string, updatedAt?: string): void;
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    listTaskRelationships(taskId: string, workspaceId?: string, options?: {
+        includeDeleted?: boolean;
+    }): TaskRelationshipRecord[];
+    getTaskRelationshipForSync(id: string, workspaceId?: string): TaskRelationshipRecord | null;
+    deleteTaskForSync(id: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        deletedAt?: string;
+        actor?: string;
+        actorType?: 'human' | 'ai' | 'system';
+        source?: 'ui' | 'mcp' | 'sync' | 'workspace-delete' | 'system';
+    }): boolean;
+}
+export type DurableTaskDeletePlan = {
+    task: TaskItem;
+    relationships: TaskRelationshipRecord[];
+};
+export type DurableTaskDeleteResult = {
+    taskTombstone: {
+        taskId: string;
+        deletedAt: string;
+    };
+    relationshipTombstones: TaskRelationshipRecord[];
+};
+export declare function prepareTaskDeleteForDurableSync(input: {
+    core: DurableTaskDeleteCore;
+    workspaceId: string;
+    taskId: string;
+}): DurableTaskDeletePlan;
+export declare function applyTaskDeleteForDurableSync(input: {
+    core: DurableTaskDeleteCore;
+    workspaceId: string;
+    taskId: string;
+    expectedRelationshipIds: string[];
+    deletedAt: string;
+    actorRef: string;
+    source?: 'ui' | 'mcp' | 'sync' | 'workspace-delete' | 'system';
+}): DurableTaskDeleteResult;

package/dist/core/TaskDurableDeleteMutationService.js

@@ -0,0 +1,54 @@
+export class DurableTaskDeleteMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskDeleteMutationError';
+    }
+}
+export function prepareTaskDeleteForDurableSync(input) {
+    const task = input.core.getTask(input.taskId, input.workspaceId);
+    if (!task)
+        throw new DurableTaskDeleteMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    const relationships = input.core.listTaskRelationships(input.taskId, input.workspaceId)
+        .filter((relationship) => !relationship.deletedAt)
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return { task, relationships };
+}
+export function applyTaskDeleteForDurableSync(input) {
+    input.core.lockTaskRelationshipMutationDomain(input.workspaceId, input.deletedAt);
+    if (!input.core.getTask(input.taskId, input.workspaceId)) {
+        throw new DurableTaskDeleteMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    }
+    const expectedIds = [...new Set(input.expectedRelationshipIds.map((id) => String(id || '').trim()).filter(Boolean))].sort();
+    const currentIds = input.core.listTaskRelationships(input.taskId, input.workspaceId)
+        .filter((relationship) => !relationship.deletedAt)
+        .map((relationship) => relationship.id)
+        .sort();
+    if (expectedIds.length !== currentIds.length || expectedIds.some((id, index) => id !== currentIds[index])) {
+        throw new DurableTaskDeleteMutationError('Task relationships changed while the delete operation was being accepted.', 'TASK_DELETE_RELATIONSHIP_SET_CHANGED', 409);
+    }
+    const deleted = input.core.deleteTaskForSync(input.taskId, input.workspaceId, {
+        persistBackup: false,
+        emitRealtime: false,
+        deletedAt: input.deletedAt,
+        actor: input.actorRef,
+        actorType: 'human',
+        source: input.source || 'sync',
+    });
+    if (!deleted)
+        throw new DurableTaskDeleteMutationError('Task delete failed.', 'TASK_DELETE_FAILED', 409);
+    const relationshipTombstones = expectedIds.map((relationshipId) => {
+        const relationship = input.core.getTaskRelationshipForSync(relationshipId, input.workspaceId);
+        if (!relationship?.deletedAt) {
+            throw new DurableTaskDeleteMutationError(`Relationship ${relationshipId} was not tombstoned by task deletion.`, 'TASK_DELETE_FAILED', 500);
+        }
+        return relationship;
+    });
+    return {
+        taskTombstone: { taskId: input.taskId, deletedAt: input.deletedAt },
+        relationshipTombstones,
+    };
+}

package/dist/core/TaskDurableLifecycleMutationService.d.ts

@@ -0,0 +1,38 @@
+import type { TaskItem } from './Taskforce.js';
+export type DurableTaskLifecycleMutationKind = 'archive' | 'unarchive';
+export declare class DurableTaskLifecycleMutationError extends Error {
+    readonly code: 'TASK_NOT_FOUND' | 'TASK_LIFECYCLE_INVALID_PAYLOAD' | 'TASK_LIFECYCLE_STATE_CONFLICT' | 'TASK_LIFECYCLE_ALREADY_ARCHIVED' | 'TASK_LIFECYCLE_NOT_ARCHIVED';
+    readonly statusCode: number;
+    constructor(message: string, code: 'TASK_NOT_FOUND' | 'TASK_LIFECYCLE_INVALID_PAYLOAD' | 'TASK_LIFECYCLE_STATE_CONFLICT' | 'TASK_LIFECYCLE_ALREADY_ARCHIVED' | 'TASK_LIFECYCLE_NOT_ARCHIVED', statusCode: number);
+}
+export interface DurableTaskLifecycleMutationCore {
+    lockTaskLifecycleMutationDomain(workspaceId?: string, updatedAt?: string): void;
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    archiveTask(id: string, isCancellation?: boolean, reason?: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        taskEventId?: string;
+        allowV3OwnedLifecycleWrite?: boolean;
+    }): TaskItem | null;
+    unarchiveTask(id: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        taskEventId?: string;
+        allowV3OwnedLifecycleWrite?: boolean;
+    }): TaskItem | null;
+}
+export declare function applyTaskLifecycleMutationForDurableSync(input: {
+    core: DurableTaskLifecycleMutationCore;
+    workspaceId: string;
+    taskId: string;
+    mutationKind: DurableTaskLifecycleMutationKind;
+    cancellation?: boolean;
+    reason?: string | null;
+    updatedAt: string;
+    actorRef: string;
+    taskEventId?: string;
+}): TaskItem;

package/dist/core/TaskDurableLifecycleMutationService.js

@@ -0,0 +1,42 @@
+export class DurableTaskLifecycleMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskLifecycleMutationError';
+    }
+}
+export function applyTaskLifecycleMutationForDurableSync(input) {
+    input.core.lockTaskLifecycleMutationDomain(input.workspaceId, input.updatedAt);
+    const current = input.core.getTask(input.taskId, input.workspaceId);
+    if (!current)
+        throw new DurableTaskLifecycleMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    if (input.mutationKind === 'archive' && current.isArchived) {
+        throw new DurableTaskLifecycleMutationError('Task is already archived.', 'TASK_LIFECYCLE_ALREADY_ARCHIVED', 409);
+    }
+    if (input.mutationKind === 'unarchive' && !current.isArchived) {
+        throw new DurableTaskLifecycleMutationError('Task is not archived.', 'TASK_LIFECYCLE_NOT_ARCHIVED', 409);
+    }
+    const updated = input.mutationKind === 'archive'
+        ? input.core.archiveTask(input.taskId, input.cancellation, input.reason || undefined, input.workspaceId, {
+            persistBackup: false,
+            emitRealtime: false,
+            syncUpdatedAt: input.updatedAt,
+            actorRef: input.actorRef,
+            taskEventId: input.taskEventId,
+            allowV3OwnedLifecycleWrite: true,
+        })
+        : input.core.unarchiveTask(input.taskId, input.workspaceId, {
+            persistBackup: false,
+            emitRealtime: false,
+            syncUpdatedAt: input.updatedAt,
+            actorRef: input.actorRef,
+            taskEventId: input.taskEventId,
+            allowV3OwnedLifecycleWrite: true,
+        });
+    if (!updated)
+        throw new DurableTaskLifecycleMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    return updated;
+}

package/dist/core/TaskDurableRelationshipMutationService.d.ts

@@ -0,0 +1,58 @@
+import type { TaskRelationshipInputType, TaskRelationshipKind, TaskRelationshipRecord } from './Taskforce.js';
+export declare class DurableTaskRelationshipMutationError extends Error {
+    readonly code: 'TASK_RELATIONSHIP_STATE_CHANGED' | 'TASK_RELATIONSHIP_MUTATION_FAILED';
+    readonly statusCode: number;
+    constructor(message: string, code: 'TASK_RELATIONSHIP_STATE_CHANGED' | 'TASK_RELATIONSHIP_MUTATION_FAILED', statusCode?: number);
+}
+export interface DurableTaskRelationshipMutationCore {
+    resolveTaskRelationshipIdentity(sourceTaskId: string, targetTaskId: string, type: TaskRelationshipInputType, workspaceId?: string): {
+        id: string;
+        sourceTaskId: string;
+        targetTaskId: string;
+        kind: TaskRelationshipKind;
+    };
+    getTaskRelationshipForSync(id: string, workspaceId?: string): TaskRelationshipRecord | null;
+    lockTaskRelationshipMutationDomain(workspaceId?: string, updatedAt?: string): void;
+    linkTaskRelationship(sourceTaskId: string, targetTaskId: string, type: TaskRelationshipInputType, workspaceId?: string, actorRef?: string, options?: {
+        persistBackup?: boolean;
+        updatedAt?: string;
+    }): {
+        relationship: TaskRelationshipRecord;
+        outcome: 'created' | 'existing' | 'reactivated';
+    };
+    unlinkTaskRelationship(sourceTaskId: string, targetTaskId: string, type: TaskRelationshipInputType, workspaceId?: string, actorRef?: string, options?: {
+        persistBackup?: boolean;
+        updatedAt?: string;
+    }): {
+        relationship: TaskRelationshipRecord | null;
+        outcome: 'removed' | 'already_absent';
+    };
+}
+export type DurableTaskRelationshipPlan = {
+    entityId: string;
+    sourceTaskId: string;
+    targetTaskId: string;
+    kind: TaskRelationshipKind;
+    mutationKind: 'link' | 'unlink';
+    revisionKind: 'metadata' | 'both';
+    priorState: TaskRelationshipRecord | null;
+};
+export declare function prepareTaskRelationshipMutationForDurableSync(input: {
+    core: DurableTaskRelationshipMutationCore;
+    workspaceId: string;
+    sourceTaskId: string;
+    targetTaskId: string;
+    type: TaskRelationshipInputType;
+    mutationKind: 'link' | 'unlink';
+}): DurableTaskRelationshipPlan;
+export declare function applyTaskRelationshipMutationForDurableSync(input: {
+    core: DurableTaskRelationshipMutationCore;
+    workspaceId: string;
+    sourceTaskId: string;
+    targetTaskId: string;
+    type: TaskRelationshipInputType;
+    mutationKind: 'link' | 'unlink';
+    expectedPriorState: TaskRelationshipRecord | null;
+    updatedAt: string;
+    actorRef: string;
+}): TaskRelationshipRecord;

package/dist/core/TaskDurableRelationshipMutationService.js

@@ -0,0 +1,66 @@
+export class DurableTaskRelationshipMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode = 409) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskRelationshipMutationError';
+    }
+}
+function relationshipStateFingerprint(value) {
+    if (!value)
+        return 'absent';
+    return JSON.stringify([
+        value.id,
+        value.workspaceId,
+        value.sourceTaskId,
+        value.targetTaskId,
+        value.kind,
+        value.createdBy,
+        value.createdAt,
+        value.updatedBy,
+        value.updatedAt,
+        value.deletedBy,
+        value.deletedAt,
+    ]);
+}
+export function prepareTaskRelationshipMutationForDurableSync(input) {
+    const identity = input.core.resolveTaskRelationshipIdentity(input.sourceTaskId, input.targetTaskId, input.type, input.workspaceId);
+    const priorState = input.core.getTaskRelationshipForSync(identity.id, input.workspaceId);
+    if (input.mutationKind === 'link' && priorState && !priorState.deletedAt) {
+        throw new DurableTaskRelationshipMutationError('Task relationship is already active.', 'TASK_RELATIONSHIP_STATE_CHANGED');
+    }
+    if (input.mutationKind === 'unlink' && (!priorState || priorState.deletedAt)) {
+        throw new DurableTaskRelationshipMutationError('Task relationship is already absent.', 'TASK_RELATIONSHIP_STATE_CHANGED');
+    }
+    return {
+        entityId: identity.id,
+        sourceTaskId: identity.sourceTaskId,
+        targetTaskId: identity.targetTaskId,
+        kind: identity.kind,
+        mutationKind: input.mutationKind,
+        revisionKind: input.mutationKind === 'unlink' || priorState ? 'both' : 'metadata',
+        priorState,
+    };
+}
+export function applyTaskRelationshipMutationForDurableSync(input) {
+    input.core.lockTaskRelationshipMutationDomain(input.workspaceId, input.updatedAt);
+    const identity = input.core.resolveTaskRelationshipIdentity(input.sourceTaskId, input.targetTaskId, input.type, input.workspaceId);
+    const current = input.core.getTaskRelationshipForSync(identity.id, input.workspaceId);
+    if (relationshipStateFingerprint(current) !== relationshipStateFingerprint(input.expectedPriorState)) {
+        throw new DurableTaskRelationshipMutationError('Task relationship changed while the operation was being accepted.', 'TASK_RELATIONSHIP_STATE_CHANGED');
+    }
+    if (input.mutationKind === 'link') {
+        const result = input.core.linkTaskRelationship(input.sourceTaskId, input.targetTaskId, input.type, input.workspaceId, input.actorRef, { persistBackup: false, updatedAt: input.updatedAt });
+        if (result.outcome === 'existing') {
+            throw new DurableTaskRelationshipMutationError('Task relationship link did not change canonical state.', 'TASK_RELATIONSHIP_MUTATION_FAILED');
+        }
+        return result.relationship;
+    }
+    const result = input.core.unlinkTaskRelationship(input.sourceTaskId, input.targetTaskId, input.type, input.workspaceId, input.actorRef, { persistBackup: false, updatedAt: input.updatedAt });
+    if (result.outcome !== 'removed' || !result.relationship) {
+        throw new DurableTaskRelationshipMutationError('Task relationship unlink did not change canonical state.', 'TASK_RELATIONSHIP_MUTATION_FAILED');
+    }
+    return result.relationship;
+}

package/dist/core/TaskDurableRestoreMutationService.d.ts

@@ -0,0 +1,31 @@
+import type { DeletedTaskRecord, TaskItem } from './Taskforce.js';
+import type { TaskRestoreDestination } from '../shared/taskRestoreDestination.js';
+export declare class DurableTaskRestoreMutationError extends Error {
+    readonly code: 'DELETED_TASK_NOT_FOUND' | 'TASK_RESTORE_CONFLICT' | 'TASK_RESTORE_FAILED';
+    readonly statusCode: number;
+    constructor(message: string, code: 'DELETED_TASK_NOT_FOUND' | 'TASK_RESTORE_CONFLICT' | 'TASK_RESTORE_FAILED', statusCode: number);
+}
+export interface DurableTaskRestoreCore {
+    lockTaskLifecycleMutationDomain(workspaceId?: string, updatedAt?: string): void;
+    getDeletedTask(id: string, workspaceId?: string): DeletedTaskRecord | null;
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    restoreDeletedTask(id: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        actorRef?: string;
+        syncUpdatedAt?: string;
+        taskEventId?: string;
+        allowV3OwnedDeleteRestore?: boolean;
+        restoreDestination?: TaskRestoreDestination;
+    }): TaskItem | null;
+}
+export declare function applyTaskRestoreForDurableSync(input: {
+    core: DurableTaskRestoreCore;
+    workspaceId: string;
+    deletedRecordId: string;
+    expectedTaskId: string;
+    restoredAt: string;
+    actorRef: string;
+    taskEventId: string;
+    restoreDestination?: TaskRestoreDestination;
+}): TaskItem;

package/dist/core/TaskDurableRestoreMutationService.js

@@ -0,0 +1,33 @@
+export class DurableTaskRestoreMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskRestoreMutationError';
+    }
+}
+export function applyTaskRestoreForDurableSync(input) {
+    input.core.lockTaskLifecycleMutationDomain(input.workspaceId, input.restoredAt);
+    const deleted = input.core.getDeletedTask(input.deletedRecordId, input.workspaceId);
+    if (!deleted || deleted.taskId !== input.expectedTaskId) {
+        throw new DurableTaskRestoreMutationError('Deleted task not found.', 'DELETED_TASK_NOT_FOUND', 404);
+    }
+    if (input.core.getTask(input.expectedTaskId, input.workspaceId)) {
+        throw new DurableTaskRestoreMutationError('A live task with this id already exists. Restore is blocked.', 'TASK_RESTORE_CONFLICT', 409);
+    }
+    const restored = input.core.restoreDeletedTask(input.deletedRecordId, input.workspaceId, {
+        persistBackup: false,
+        emitRealtime: false,
+        actorRef: input.actorRef,
+        syncUpdatedAt: input.restoredAt,
+        taskEventId: input.taskEventId,
+        allowV3OwnedDeleteRestore: true,
+        restoreDestination: input.restoreDestination,
+    });
+    if (!restored || restored.id !== input.expectedTaskId) {
+        throw new DurableTaskRestoreMutationError('Task restore failed.', 'TASK_RESTORE_FAILED', 500);
+    }
+    return restored;
+}