@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/sync/v3/localOutboxDispatchRuntime.js

@@ -0,0 +1,269 @@
+import { createLocalInitiativeOutboxHandler } from './localInitiativeOutboxHandler.js';
+import { requeueOutboxOperationsValidUnderCurrentContract, } from './localOutboxDispatcher.js';
+import { createLocalTaskAttachmentLinksOutboxHandler } from './localTaskAttachmentLinksOutboxHandler.js';
+import { createLocalTaskChecklistOutboxHandler } from './localTaskChecklistOutboxHandler.js';
+import { createLocalTaskCommentOutboxHandler } from './localTaskCommentOutboxHandler.js';
+import { createLocalTaskCreateOutboxHandler } from './localTaskCreateOutboxHandler.js';
+import { createLocalTaskDeleteOutboxHandler } from './localTaskDeleteOutboxHandler.js';
+import { createLocalTaskLegacyRootAdoptionHandler } from './localTaskLegacyRootAdoption.js';
+import { enqueueLocalTaskLegacyRootAdoption, } from './localTaskLegacyRootAdoption.js';
+import { createLocalTaskLifecycleOutboxHandler } from './localTaskLifecycleOutboxHandler.js';
+import { createLocalTaskMetadataOutboxHandler } from './localTaskMetadataOutboxHandler.js';
+import { createLocalTaskRelationshipOutboxHandler } from './localTaskRelationshipOutboxHandler.js';
+import { enqueueLocalTaskRelationshipLegacyAdoption, } from './localTaskRelationshipOutboxService.js';
+import { createLocalTaskRestoreOutboxHandler } from './localTaskRestoreOutboxHandler.js';
+import { createLocalTaskStatusOutboxHandler } from './localTaskStatusOutboxHandler.js';
+import { LocalSyncIdentityStore } from './localSyncIdentityStore.js';
+import { fingerprintWorkspaceSyncPayload, } from './syncDurabilityStore.js';
+import { createLocalTaxonomyOutboxHandler } from './localTaxonomyOutboxHandler.js';
+import { serializeTaskRootForSync } from './workspaceSyncV3TaskRootProjection.js';
+import { createLocalWorkflowRuntimeOutboxHandler } from './localWorkflowRuntimeOutboxHandler.js';
+import { createLocalWorkstreamOutboxHandler } from './localWorkstreamOutboxHandler.js';
+import { createLocalWorkstreamTaskOrderOutboxHandler } from './localWorkstreamTaskOrderOutboxHandler.js';
+import { resolveWorkflowRuntimeMutationCapability } from './durableWorkflowRuntimeMutationRouter.js';
+import { createLocalEntityEventLegacyAdoptionHandler, enqueueNextLegacyEntityEventAdoption, } from './localEntityEventLegacyAdoption.js';
+export function createLocalOutboxDispatchHandlers(input) {
+    return [
+        createLocalTaskMetadataOutboxHandler(input),
+        createLocalTaskLegacyRootAdoptionHandler(input),
+        createLocalTaskCreateOutboxHandler(input),
+        createLocalTaskDeleteOutboxHandler(input),
+        createLocalTaskRestoreOutboxHandler(input),
+        createLocalTaskRelationshipOutboxHandler(input),
+        createLocalTaskLifecycleOutboxHandler(input),
+        createLocalTaskStatusOutboxHandler(input),
+        createLocalTaskCommentOutboxHandler(input),
+        createLocalTaskChecklistOutboxHandler(input),
+        createLocalTaskAttachmentLinksOutboxHandler(input),
+        createLocalEntityEventLegacyAdoptionHandler(input),
+        createLocalTaxonomyOutboxHandler(input),
+        createLocalInitiativeOutboxHandler(input),
+        createLocalWorkstreamOutboxHandler(input),
+        createLocalWorkstreamTaskOrderOutboxHandler(input),
+        ...(resolveWorkflowRuntimeMutationCapability({
+            runtimeMode: 'local',
+            surface: 'http',
+            env: input.env || process.env,
+        }) ? [createLocalWorkflowRuntimeOutboxHandler(input)] : []),
+    ];
+}
+function enqueueNextLegacyTaskRootAdoption(input) {
+    const tenantId = input.core.getTenantId();
+    if (input.store.readCombinedProjectionOwnership({
+        tenantId,
+        workspaceId: input.workspaceId,
+    }).owner !== 'v3') {
+        return false;
+    }
+    let cursor = null;
+    do {
+        const page = (input.core.listTasksForSync(input.workspaceId, cursor, 1000));
+        for (const entry of page) {
+            const task = entry.task;
+            if (task.referenceNumber !== null
+                || !Number.isInteger(task.localReferenceNumber)
+                || Number(task.localReferenceNumber) < 1) {
+                continue;
+            }
+            const ownership = input.store.readWorkspaceDomainOwnership({
+                tenantId,
+                workspaceId: input.workspaceId,
+                domain: 'task',
+                entityId: task.id,
+            });
+            if (ownership.owned
+                || ownership.activeOperation
+                || ownership.entityRevision !== '0') {
+                continue;
+            }
+            const rootFingerprint = fingerprintWorkspaceSyncPayload(serializeTaskRootForSync(task));
+            const clientId = new LocalSyncIdentityStore(input.core.getDatabaseAdapter()).getOrCreateClientId(input.now);
+            return enqueueLocalTaskLegacyRootAdoption({
+                store: input.store,
+                core: input.core,
+                identity: {
+                    tenantId,
+                    workspaceId: input.workspaceId,
+                    clientId,
+                    operationId: `legacy-root-adoption-${task.id}-${rootFingerprint}`,
+                },
+                taskId: task.id,
+                now: input.now,
+            }).enqueued;
+        }
+        const last = page.at(-1);
+        cursor = page.length === 1000 && last
+            ? {
+                watermark: String(last.task.updatedAt || last.task.createdAt),
+                id: last.task.id,
+            }
+            : null;
+    } while (cursor);
+    return false;
+}
+function enqueueNextLegacyTaskRelationshipAdoption(input) {
+    const tenantId = input.core.getTenantId();
+    if (input.store.readCombinedProjectionOwnership({
+        tenantId,
+        workspaceId: input.workspaceId,
+    }).owner !== 'v3') {
+        return false;
+    }
+    let cursor = null;
+    do {
+        const page = input.core.listTaskRelationshipsForSync(input.workspaceId, cursor, 1000);
+        for (const relationship of page) {
+            const ownership = input.store.readWorkspaceDomainOwnership({
+                tenantId,
+                workspaceId: input.workspaceId,
+                domain: 'task-relationship',
+                entityId: relationship.id,
+            });
+            if (ownership.owned || ownership.activeOperation || ownership.entityRevision !== '0') {
+                continue;
+            }
+            const endpointTasksOwned = [
+                relationship.sourceTaskId,
+                relationship.targetTaskId,
+            ].every((entityId) => input.store.readWorkspaceDomainOwnership({
+                tenantId,
+                workspaceId: input.workspaceId,
+                domain: 'task',
+                entityId,
+            }).owned);
+            if (!endpointTasksOwned)
+                continue;
+            const fingerprint = fingerprintWorkspaceSyncPayload(relationship);
+            const clientId = new LocalSyncIdentityStore(input.core.getDatabaseAdapter()).getOrCreateClientId(input.now);
+            return enqueueLocalTaskRelationshipLegacyAdoption({
+                store: input.store,
+                core: input.core,
+                identity: {
+                    tenantId,
+                    workspaceId: input.workspaceId,
+                    clientId,
+                    operationId: `legacy-relationship-adoption-${relationship.id}-${fingerprint}`,
+                },
+                relationship,
+                now: input.now,
+            }).enqueued;
+        }
+        const last = page.at(-1);
+        cursor = page.length === 1000 && last
+            ? {
+                watermark: last.updatedAt,
+                id: `task-relationship:${last.id}`,
+            }
+            : null;
+    } while (cursor);
+    return false;
+}
+export function prepareLocalOutboxDispatch(input) {
+    const tenantId = input.core.getTenantId();
+    requeueOutboxOperationsValidUnderCurrentContract({
+        store: input.store,
+        handlers: input.handlers,
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueLegacyPlanningAttachmentAcknowledgements({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueSupersededTaskAttachmentReferenceMetadataConflicts({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueSupersededOriginDispatchAuthorizationFailures({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueSupersededTaskCreateChecklistAcknowledgements({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueInitialTaskCreateRouteMisses({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueSupersededTaskCommentReconciliationConflicts({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueTaskCommentRootAcknowledgementConflicts({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueBoundedTaskStatusRevisionConflicts({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueBoundedWorkstreamMetadataRevisionConflicts({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueWorkstreamInitiativeDependencyAcknowledgements({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueBoundedInitiativeMetadataRevisionConflicts({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueTaskCommentProvenanceReconciliationConflicts({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueSupersededTaskStatusWorkflowAcknowledgements({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueTaskStatusAssigneeAcknowledgements({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.requeueTaskStatusWorkflowHistoryAcknowledgements({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    input.store.supersedeArchivedReadOnlyTaskRecoveryIntents({
+        tenantId,
+        workspaceId: input.workspaceId,
+        now: input.now,
+        isTaskArchived: (taskId) => input.core.getTask(taskId, input.workspaceId)?.isArchived === true,
+    });
+    enqueueNextLegacyTaskRootAdoption({
+        core: input.core,
+        store: input.store,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    enqueueNextLegacyTaskRelationshipAdoption({
+        core: input.core,
+        store: input.store,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+    enqueueNextLegacyEntityEventAdoption({
+        core: input.core,
+        store: input.store,
+        workspaceId: input.workspaceId,
+        now: input.now,
+    });
+}

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

@@ -0,0 +1,53 @@
+import { type LocalOutboxOperationHandler, type LocalOutboxRetryDependency } from './localOutboxOperationHandler.js';
+import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOutboxDispatchClass, type WorkspaceSyncOutboxRecord } from './syncDurabilityStore.js';
+import type { WorkspaceSyncV3OperationEnvelope, WorkspaceSyncV3TaskMetadataEnvelope } from './workspaceSyncV3OperationProtocol.js';
+export declare const MAX_INITIAL_TASK_NOT_FOUND_ATTEMPTS = 12;
+export type LocalOutboxTransportResult = {
+    ok: boolean;
+    status: number;
+    data: unknown;
+    retryAfterMs?: number;
+    acceptedSettlement?: {
+        complete<T>(applyAuthoritativeAndAck: () => T): T;
+        abandon(errorCode: string): void;
+    };
+};
+export type TaskMetadataOperationEnvelope = WorkspaceSyncV3TaskMetadataEnvelope;
+export type LocalOutboxDispatchOutcome = {
+    clientId: string;
+    operationId: string;
+    disposition: 'accepted' | 'retry' | 'blocked' | 'lease-lost';
+    errorCode?: string;
+    retryDependency?: LocalOutboxRetryDependency;
+    schedulerAction?: 'v2-content-push-required';
+};
+export declare function calculateLocalOutboxRetryDelayMs(attemptCount: number, random?: () => number): number;
+export declare function requeueOutboxOperationsValidUnderCurrentContract(input: {
+    store: WorkspaceSyncDurabilityStore;
+    handlers: readonly LocalOutboxOperationHandler[];
+    tenantId: string;
+    workspaceId: string;
+    now: string;
+    limit?: number;
+}): number;
+export declare function dispatchLocalOutboxBatch(input: {
+    store: WorkspaceSyncDurabilityStore;
+    handlers: readonly LocalOutboxOperationHandler[];
+    tenantId: string;
+    workspaceId: string;
+    transport: (envelope: WorkspaceSyncV3OperationEnvelope, options: {
+        timeoutMs: number;
+    }) => Promise<LocalOutboxTransportResult>;
+    now?: () => Date;
+    leaseOwner?: string;
+    leaseMs?: number;
+    transportTimeoutMs?: number;
+    limit?: number;
+    retryDelayMs?: (attemptCount: number) => number;
+    onError?: (error: unknown, record: WorkspaceSyncOutboxRecord) => void;
+    beforeTransport?: (record: WorkspaceSyncOutboxRecord) => void;
+    dispatchClasses?: readonly WorkspaceSyncOutboxDispatchClass[];
+}): Promise<{
+    claimed: number;
+    outcomes: LocalOutboxDispatchOutcome[];
+}>;

package/dist/sync/v3/localOutboxDispatcher.js

@@ -0,0 +1,362 @@
+import { randomUUID } from 'crypto';
+import { resolveLocalOutboxOperationHandler, } from './localOutboxOperationHandler.js';
+import { WorkspaceSyncLeaseLostError, } from './syncDurabilityStore.js';
+const DEFAULT_LEASE_MS = 30_000;
+const DEFAULT_TRANSPORT_TIMEOUT_MS = 20_000;
+const MAX_ERROR_MESSAGE_LENGTH = 400;
+const MAX_SERVER_RETRY_DELAY_MS = 24 * 60 * 60_000;
+export const MAX_INITIAL_TASK_NOT_FOUND_ATTEMPTS = 12;
+function boundedMessage(value, fallback) {
+    const normalized = String(value || fallback).replace(/\s+/g, ' ').trim() || fallback;
+    return normalized.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+}
+function errorDetails(data, fallbackCode, fallbackMessage) {
+    const body = data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+    return {
+        code: boundedMessage(body.code, fallbackCode),
+        message: boundedMessage(body.error, fallbackMessage),
+    };
+}
+export function calculateLocalOutboxRetryDelayMs(attemptCount, random = Math.random) {
+    const attempt = Math.max(1, Math.min(20, Math.floor(attemptCount || 1)));
+    const ceiling = Math.min(5 * 60_000, 1_000 * (2 ** (attempt - 1)));
+    const jitter = Math.max(0, Math.min(0.999999, Number(random()) || 0));
+    return Math.max(1_000, Math.floor(ceiling * jitter));
+}
+function identity(record) {
+    return {
+        tenantId: record.tenantId,
+        workspaceId: record.workspaceId,
+        clientId: record.clientId,
+        operationId: record.operationId,
+    };
+}
+export function requeueOutboxOperationsValidUnderCurrentContract(input) {
+    const candidates = input.store.listBlockedInvalidOutboxOperations({
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        limit: input.limit,
+    });
+    let recovered = 0;
+    for (const record of candidates) {
+        try {
+            const handler = resolveLocalOutboxOperationHandler(input.handlers, record);
+            handler.buildEnvelope(record);
+        }
+        catch {
+            continue;
+        }
+        if (input.store.requeueBlockedInvalidOutboxOperation({
+            identity: identity(record),
+            now: input.now,
+        })) {
+            recovered += 1;
+        }
+    }
+    return recovered;
+}
+function isTransientStatus(status) {
+    return status === 0 || status === 401 || (status >= 300 && status < 400)
+        || status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function operationRetryAt(data, nowMs) {
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return 0;
+    const body = data;
+    if (body.code !== 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS')
+        return 0;
+    const retryAt = Date.parse(String(body.retryAt || ''));
+    return Number.isFinite(retryAt) ? Math.max(0, retryAt - nowMs) : 0;
+}
+function isOperationInProgress(data) {
+    return Boolean(data && typeof data === 'object' && !Array.isArray(data)
+        && data.code === 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS');
+}
+function isCloudV3Disabled(record, data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return false;
+    const code = String(data.code || '');
+    return code === 'WORKSPACE_SYNC_V3_DISABLED'
+        || (code === 'WORKSPACE_SYNC_V3_TAXONOMY_DISABLED' && record.domain === 'taxonomy')
+        || (code === 'WORKSPACE_SYNC_V3_INITIATIVE_DISABLED' && record.domain === 'initiative')
+        || (code === 'WORKSPACE_SYNC_V3_TASK_COMMENTS_DISABLED' && record.domain === 'task-comments')
+        || (code === 'WORKSPACE_SYNC_V3_TASK_CHECKLIST_DISABLED' && record.domain === 'task-checklist')
+        || (code === 'WORKSPACE_SYNC_V3_TASK_ATTACHMENT_LINKS_DISABLED' && record.domain === 'task-attachment-links');
+}
+function isInitialTaskMetadataNotFound(record, result) {
+    return result.status === 404
+        && Boolean(result.data && typeof result.data === 'object' && !Array.isArray(result.data)
+            && result.data.code === 'TASK_NOT_FOUND')
+        && record.domain === 'task'
+        && record.mutationKind === 'metadata-update'
+        && record.baseEntityRevision === '0'
+        && record.baseLifecycleRevision === '0'
+        && record.initialNotFoundAttemptCount < MAX_INITIAL_TASK_NOT_FOUND_ATTEMPTS;
+}
+function isInitialTaskCreateWorkstreamNotFound(record, result) {
+    return result.status === 400
+        && Boolean(result.data && typeof result.data === 'object' && !Array.isArray(result.data)
+            && result.data.code === 'WORKSTREAM_NOT_FOUND')
+        && record.domain === 'task'
+        && record.mutationKind === 'create'
+        && record.initialNotFoundAttemptCount < MAX_INITIAL_TASK_NOT_FOUND_ATTEMPTS;
+}
+function isTaskCommentReconciliationRevisionConflict(record, result) {
+    return result.status === 409
+        && record.domain === 'task-comments'
+        && record.mutationKind === 'reconcile'
+        && Boolean(result.data && typeof result.data === 'object' && !Array.isArray(result.data)
+            && result.data.code === 'WORKSPACE_SYNC_REVISION_CONFLICT');
+}
+export async function dispatchLocalOutboxBatch(input) {
+    const now = input.now || (() => new Date());
+    const leaseMs = Math.max(2, Math.floor(input.leaseMs ?? DEFAULT_LEASE_MS));
+    const transportTimeoutMs = Math.max(1, Math.floor(input.transportTimeoutMs ?? DEFAULT_TRANSPORT_TIMEOUT_MS));
+    const limit = Math.max(1, Math.min(100, Math.floor(input.limit ?? 1)));
+    if (transportTimeoutMs * limit >= leaseMs) {
+        throw new Error('Outbox lease must outlast the worst-case sequential transport batch.');
+    }
+    const claimedAt = now();
+    const claim = input.store.claimOutbox({
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        leaseOwner: input.leaseOwner || `dispatcher-${randomUUID()}`,
+        now: claimedAt.toISOString(),
+        leaseExpiresAt: new Date(claimedAt.getTime() + leaseMs).toISOString(),
+        limit,
+        dispatchClasses: input.dispatchClasses,
+    });
+    const outcomes = [];
+    for (const record of claim.records) {
+        const operationIdentity = identity(record);
+        const block = (code, message) => input.store.blockOutboxClaim({
+            identity: operationIdentity,
+            leaseOwner: claim.leaseOwner,
+            now: now().toISOString(),
+            errorCode: boundedMessage(code, 'WORKSPACE_SYNC_OUTBOX_BLOCKED'),
+            errorMessage: boundedMessage(message, 'Local outbox operation is blocked.'),
+        });
+        try {
+            let handler;
+            let envelope;
+            try {
+                handler = resolveLocalOutboxOperationHandler(input.handlers, record);
+                envelope = handler.buildEnvelope(record);
+            }
+            catch (error) {
+                block('WORKSPACE_SYNC_OUTBOX_INVALID', error.message);
+                outcomes.push({ clientId: record.clientId, operationId: record.operationId, disposition: 'blocked', errorCode: 'WORKSPACE_SYNC_OUTBOX_INVALID' });
+                continue;
+            }
+            const readiness = handler.resolveDispatchReadiness?.(record);
+            if (readiness && !readiness.ready) {
+                if (!readiness.retryable) {
+                    block(readiness.errorCode, readiness.errorMessage);
+                    outcomes.push({
+                        clientId: record.clientId,
+                        operationId: record.operationId,
+                        disposition: 'blocked',
+                        errorCode: readiness.errorCode,
+                    });
+                    continue;
+                }
+                const releasedAt = now();
+                const retryDelay = Math.max(1_000, Math.floor((input.retryDelayMs || calculateLocalOutboxRetryDelayMs)(record.attemptCount)));
+                input.store.releaseOutboxClaim({
+                    identity: operationIdentity,
+                    leaseOwner: claim.leaseOwner,
+                    now: releasedAt.toISOString(),
+                    nextAttemptAt: new Date(releasedAt.getTime() + retryDelay).toISOString(),
+                    errorCode: readiness.errorCode,
+                    errorMessage: readiness.errorMessage,
+                });
+                outcomes.push({
+                    clientId: record.clientId,
+                    operationId: record.operationId,
+                    disposition: 'retry',
+                    errorCode: readiness.errorCode,
+                });
+                continue;
+            }
+            try {
+                input.beforeTransport?.(record);
+            }
+            catch (error) {
+                const releasedAt = now();
+                input.store.releaseOutboxClaim({
+                    identity: operationIdentity,
+                    leaseOwner: claim.leaseOwner,
+                    now: releasedAt.toISOString(),
+                    nextAttemptAt: new Date(releasedAt.getTime() + 1_000).toISOString(),
+                    errorCode: 'WORKSPACE_SYNC_FAIRNESS_CHECKPOINT_FAILED',
+                    errorMessage: boundedMessage(error?.message, 'Failed to persist sync fairness before transport.'),
+                });
+                outcomes.push({
+                    clientId: record.clientId,
+                    operationId: record.operationId,
+                    disposition: 'retry',
+                    errorCode: 'WORKSPACE_SYNC_FAIRNESS_CHECKPOINT_FAILED',
+                });
+                continue;
+            }
+            let result;
+            try {
+                result = await input.transport(envelope, { timeoutMs: transportTimeoutMs });
+            }
+            catch (error) {
+                result = { ok: false, status: 0, data: { error: boundedMessage(error?.message, 'Network failure.') } };
+            }
+            if (result.ok && result.status === 200) {
+                try {
+                    const applyAuthoritativeAndAck = () => handler.applyAuthoritative({
+                        record,
+                        identity: operationIdentity,
+                        leaseOwner: claim.leaseOwner,
+                        response: result.data,
+                        now: now().toISOString(),
+                    });
+                    if (result.acceptedSettlement) {
+                        result.acceptedSettlement.complete(applyAuthoritativeAndAck);
+                    }
+                    else {
+                        applyAuthoritativeAndAck();
+                    }
+                    outcomes.push({ clientId: record.clientId, operationId: record.operationId, disposition: 'accepted' });
+                }
+                catch (error) {
+                    try {
+                        result.acceptedSettlement?.abandon(String(error?.code
+                            || 'WORKSPACE_SYNC_AUTHORITATIVE_APPLY_FAILED'));
+                    }
+                    catch {
+                        // Permit expiry/restart recovery remains authoritative
+                        // when a stale generation cannot abandon directly.
+                    }
+                    if (error instanceof WorkspaceSyncLeaseLostError)
+                        throw error;
+                    if (handler.isPermanentApplyError(error)) {
+                        const code = String(error.code || 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID');
+                        block(code, error.message);
+                        outcomes.push({ clientId: record.clientId, operationId: record.operationId, disposition: 'blocked', errorCode: code });
+                    }
+                    else {
+                        const releasedAt = now();
+                        const retryDependency = handler.resolveRetryDependency?.(error) || null;
+                        const retryDelay = retryDependency
+                            ? 0
+                            : Math.max(1_000, Math.floor((input.retryDelayMs || calculateLocalOutboxRetryDelayMs)(record.attemptCount)));
+                        const retryErrorCode = retryDependency
+                            ? String(error.code || 'WORKSPACE_SYNC_LOCAL_APPLY_DEPENDENCY_PENDING')
+                            : 'WORKSPACE_SYNC_LOCAL_APPLY_FAILED';
+                        input.store.releaseOutboxClaim({
+                            identity: operationIdentity,
+                            leaseOwner: claim.leaseOwner,
+                            now: releasedAt.toISOString(),
+                            nextAttemptAt: new Date(releasedAt.getTime() + retryDelay).toISOString(),
+                            errorCode: retryErrorCode,
+                            errorMessage: boundedMessage(error.message, 'Failed to install authoritative workspace state.'),
+                        });
+                        outcomes.push({
+                            clientId: record.clientId,
+                            operationId: record.operationId,
+                            disposition: 'retry',
+                            errorCode: retryErrorCode,
+                            ...(retryDependency ? { retryDependency } : {}),
+                        });
+                    }
+                }
+                continue;
+            }
+            if (result.acceptedSettlement) {
+                try {
+                    result.acceptedSettlement.abandon('WORKSPACE_SYNC_ACCEPTED_RESPONSE_NOT_APPLIED');
+                }
+                catch {
+                    // Permit expiry/restart recovery remains authoritative
+                    // when a stale generation cannot abandon directly.
+                }
+            }
+            const details = errorDetails(result.data, `WORKSPACE_SYNC_TRANSPORT_${result.status || 'NETWORK'}`, 'Workspace sync delivery failed.');
+            const stableErrorCode = result.status === 401 ? 'WORKSPACE_SYNC_TRANSPORT_401' : details.code;
+            const contentPushRequired = result.status === 425
+                && stableErrorCode === 'TASK_ATTACHMENT_ASSET_NOT_READY';
+            const inProgressDelay = operationRetryAt(result.data, now().getTime());
+            const cloudV3Disabled = result.status === 404 && isCloudV3Disabled(record, result.data);
+            // A first metadata edit may dispatch before legacy reconciliation has
+            // seeded the cloud entity. Retry only that zero-revision TASK_NOT_FOUND
+            // case, and bound it so a genuinely orphaned operation eventually blocks.
+            const initialTaskNotFound = isInitialTaskMetadataNotFound(record, result);
+            const initialWorkstreamNotFound = isInitialTaskCreateWorkstreamNotFound(record, result);
+            const reconciliationRolloutConflict = isTaskCommentReconciliationRevisionConflict(record, result);
+            const transient = isTransientStatus(result.status)
+                || isOperationInProgress(result.data)
+                || cloudV3Disabled
+                || initialTaskNotFound
+                || initialWorkstreamNotFound
+                || reconciliationRolloutConflict;
+            if (transient) {
+                // contentPushRequired used to retry with zero delay, relying on
+                // the (now-removed) accidental ~30s cloud reservation lease as
+                // an implicit floor. Bound it explicitly with the same
+                // exponential backoff as every other transient failure so a
+                // wake that fires before content actually publishes cannot
+                // hot-loop reservation attempts against the same identity.
+                const localDelay = Math.max(1_000, Math.floor((input.retryDelayMs || calculateLocalOutboxRetryDelayMs)(record.attemptCount)));
+                const rolloutDelay = result.status === 401 || (result.status >= 300 && result.status < 400)
+                    || cloudV3Disabled || initialTaskNotFound || initialWorkstreamNotFound ? 30_000 : 0;
+                const serverDelayRaw = Number(result.retryAfterMs || 0);
+                const serverDelay = Number.isFinite(serverDelayRaw)
+                    ? Math.min(MAX_SERVER_RETRY_DELAY_MS, Math.max(0, Math.floor(serverDelayRaw)))
+                    : 0;
+                const retryDelay = Math.min(MAX_SERVER_RETRY_DELAY_MS, Math.max(localDelay, serverDelay, inProgressDelay, rolloutDelay));
+                const releasedAt = now();
+                input.store.releaseOutboxClaim({
+                    identity: operationIdentity,
+                    leaseOwner: claim.leaseOwner,
+                    now: releasedAt.toISOString(),
+                    nextAttemptAt: new Date(releasedAt.getTime() + retryDelay).toISOString(),
+                    errorCode: stableErrorCode,
+                    errorMessage: details.message,
+                    incrementInitialNotFoundAttemptCount: initialTaskNotFound || initialWorkstreamNotFound,
+                });
+                outcomes.push({
+                    clientId: record.clientId,
+                    operationId: record.operationId,
+                    disposition: 'retry',
+                    errorCode: stableErrorCode,
+                    ...(contentPushRequired
+                        ? { schedulerAction: 'v2-content-push-required' }
+                        : {}),
+                });
+            }
+            else {
+                block(stableErrorCode, details.message);
+                outcomes.push({ clientId: record.clientId, operationId: record.operationId, disposition: 'blocked', errorCode: stableErrorCode });
+            }
+        }
+        catch (error) {
+            try {
+                input.onError?.(error, record);
+            }
+            catch { /* observer failures do not alter durable state */ }
+            let disposition = 'lease-lost';
+            let errorCode = error instanceof WorkspaceSyncLeaseLostError ? error.code : 'WORKSPACE_SYNC_DISPATCH_FAILED';
+            if (!(error instanceof WorkspaceSyncLeaseLostError)) {
+                try {
+                    block(errorCode, boundedMessage(error.message, 'Unexpected local outbox dispatch failure.'));
+                    disposition = 'blocked';
+                }
+                catch (blockError) {
+                    errorCode = blockError instanceof WorkspaceSyncLeaseLostError ? blockError.code : errorCode;
+                }
+            }
+            outcomes.push({
+                clientId: record.clientId,
+                operationId: record.operationId,
+                disposition,
+                errorCode,
+            });
+        }
+    }
+    return { claimed: claim.records.length, outcomes };
+}