@taskforcehq/taskforce 0.3.329 → 0.3.330

package/dist/sync/v3/localTaskStatusOutboxService.js

@@ -1,12 +1,15 @@
 import { applyTaskStatusMutationForDurableSync, validateDurableTaskStatusMutationPayload, } from '../../core/TaskDurableStatusMutationService.js';
 import { serializeTaskForSync } from '../taskSyncPayload.js';
 import { buildTaskLifecycleActivityEventId } from './taskLifecycleActivityIdentity.js';
+import { buildTaskCommentActivityEventId } from './taskCommentActivityIdentity.js';
 import { validateTaskActivityAuthoritativeRevision } from './taskActivityAuthoritativeRevision.js';
 import { serializeEntityActivityForSync, serializeTaskActivityForSync, WORKSPACE_SYNC_ENTITY_EVENT_APPEND, WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN, } from './taskActivityJournal.js';
 import { fingerprintWorkspaceSyncPayload, } from './syncDurabilityStore.js';
 import { WorkflowStore } from '../../storage/workflowStore.js';
 import { normalizeTaskStatusOperationWithWorkflowAssignment, normalizeWorkflowAssignmentSyncRecord, } from './workflowAssignmentSync.js';
 import { withOriginActorPayload } from './workspaceSyncV3OriginActor.js';
+import { mergeWorkspaceSyncV3TaskCommentsPayload, serializeWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 export class LocalAuthoritativeTaskStatusError extends Error {
     code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID';
     constructor(message) {
@@ -19,6 +22,16 @@ function isCanonicalIso(value) {
         && Number.isFinite(Date.parse(value))
         && new Date(value).toISOString() === value;
 }
+function nextTaskUpdatedAt(current, requested) {
+    const currentMs = Date.parse(current);
+    const requestedMs = Date.parse(requested);
+    if (!Number.isFinite(requestedMs) || new Date(requestedMs).toISOString() !== requested) {
+        throw new LocalAuthoritativeTaskStatusError('Task status operation timestamp is invalid.');
+    }
+    return Number.isFinite(currentMs) && currentMs >= requestedMs
+        ? new Date(currentMs + 1).toISOString()
+        : requested;
+}
 function normalizeAssignee(value) {
     const normalized = typeof value === 'string' ? value.trim() : '';
     return normalized && normalized.toLowerCase() !== 'unassigned' ? normalized : null;
@@ -46,13 +59,27 @@ export function enqueueLocalTaskStatusMutation(input) {
     const taskId = String(input.taskId || '').trim();
     if (!taskId)
         throw new LocalAuthoritativeTaskStatusError('Task id is required.');
-    const statusPayload = validateDurableTaskStatusMutationPayload(input.payload);
+    const operationPayload = normalizeTaskStatusOperationWithWorkflowAssignment(input.payload);
+    const statusPayload = validateDurableTaskStatusMutationPayload({
+        status: operationPayload.status,
+        assigneeIntent: operationPayload.assigneeIntent,
+        canceledReason: operationPayload.canceledReason,
+        metadataPatch: operationPayload.metadataPatch,
+    });
     const assignment = statusPayload.status === 'in-progress'
         ? new WorkflowStore(input.core.getDatabaseAdapter(), input.core.getTenantId())
             .getAssignmentForTaskSync(input.identity.workspaceId, taskId)
         : null;
+    const reviewHandoff = operationPayload.reviewHandoff ? {
+        comment: {
+            ...operationPayload.reviewHandoff.comment,
+            author: input.actorRef,
+            submittedAuthor: input.actorRef,
+        },
+    } : null;
     const payload = {
-        ...statusPayload,
+        ...operationPayload,
+        ...(reviewHandoff ? { reviewHandoff } : {}),
         ...(assignment?.execution.status === 'pending' ? { workflowAssignment: assignment } : {}),
     };
     const activityEventId = buildTaskLifecycleActivityEventId({
@@ -62,6 +89,23 @@ export function enqueueLocalTaskStatusMutation(input) {
         taskId,
         mutationKind: 'set-status',
     });
+    const reviewComment = payload.reviewHandoff ? {
+        ...payload.reviewHandoff.comment,
+        timestamp: input.now,
+    } : null;
+    const reviewCommentActivityEventId = reviewComment ? buildTaskCommentActivityEventId({
+        workspaceId: input.identity.workspaceId,
+        clientId: input.identity.clientId,
+        operationId: input.identity.operationId,
+        taskId,
+        commentId: reviewComment.id,
+    }) : null;
+    const reviewCommentRevision = reviewComment ? input.store.readEntityRevisionCoordinates({
+        tenantId: input.identity.tenantId,
+        workspaceId: input.identity.workspaceId,
+        domain: 'task-comments',
+        entityId: taskId,
+    }) : null;
     const result = input.store.enqueueLocalOperation({
         identity: input.identity,
         domain: 'task',
@@ -74,6 +118,15 @@ export function enqueueLocalTaskStatusMutation(input) {
             taskLifecycle: true,
             taskAssignee: payload.assigneeIntent.kind !== 'preserve',
         },
+        ...(reviewComment ? {
+            additionalTargets: [{
+                    domain: 'task-comments',
+                    entityId: taskId,
+                    mutationKind: 'append',
+                    baseEntityRevision: reviewCommentRevision.entityRevision,
+                    baseLifecycleRevision: reviewCommentRevision.lifecycleRevision,
+                }],
+        } : {}),
         payload: withOriginActorPayload({
             ...payload,
             ...(input.expectedDetailRevision
@@ -92,7 +145,7 @@ export function enqueueLocalTaskStatusMutation(input) {
                 }
                 input.core.assertTaskDetailRevisionForUpdate(taskId, input.expectedDetailRevision, input.identity.workspaceId);
             }
-            return applyTaskStatusMutationForDurableSync({
+            let mutation = applyTaskStatusMutationForDurableSync({
                 core: input.core,
                 workspaceId: input.identity.workspaceId,
                 taskId,
@@ -104,6 +157,35 @@ export function enqueueLocalTaskStatusMutation(input) {
                 actorRef: input.actorRef,
                 taskEventId: activityEventId,
             });
+            if (reviewComment) {
+                const comments = serializeWorkspaceSyncV3TaskCommentsPayload({
+                    taskId,
+                    comments: mutation.task.comments || [],
+                }).comments;
+                if (comments.some((comment) => comment.id === reviewComment.id)) {
+                    throw new LocalAuthoritativeTaskStatusError(`Review handoff comment identity conflict: ${reviewComment.id}.`);
+                }
+                const updatedAt = nextTaskUpdatedAt(String(mutation.task.updatedAt || mutation.task.createdAt), input.now);
+                const updated = input.core.updateTask(taskId, { comments: [...comments, reviewComment] }, input.identity.workspaceId, {
+                    persistBackup: false,
+                    emitRealtime: false,
+                    skipTaskEvents: true,
+                    syncUpdatedAt: updatedAt,
+                    allowV3OwnedMetadataWrite: true,
+                });
+                if (!updated)
+                    throw new LocalAuthoritativeTaskStatusError('Review handoff task disappeared.');
+                input.core.addTaskCommentEventForDurableSync({
+                    taskId,
+                    workspaceId: input.identity.workspaceId,
+                    actor: input.actorRef,
+                    eventId: reviewCommentActivityEventId,
+                    createdAt: String(updated.updatedAt),
+                    comment: reviewComment,
+                });
+                mutation = { ...mutation, task: updated };
+            }
+            return mutation;
         },
         buildCanonicalIntent: (result) => ({
             metadataPatch: Object.fromEntries(Object.keys(payload.metadataPatch).map((key) => [
@@ -117,7 +199,7 @@ export function enqueueLocalTaskStatusMutation(input) {
     const mutationResult = result.mutationResult;
     if (!mutationResult)
         throw new LocalAuthoritativeTaskStatusError('Local task status mutation result is missing.');
-    if (!mutationResult.noOp) {
+    if (!mutationResult.noOp || reviewComment) {
         try {
             input.core.notifyDurableTaskLifecycleCommitted(input.identity.workspaceId, taskId);
         }
@@ -174,6 +256,66 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
         throw new LocalAuthoritativeTaskStatusError('Persisted task status payload fingerprint is invalid.');
     }
     const operationPayload = normalizeTaskStatusOperationWithWorkflowAssignment(persistedPayload);
+    const requestedReviewHandoff = operationPayload.reviewHandoff || null;
+    const reviewHandoff = response.reviewHandoff || null;
+    if (Boolean(requestedReviewHandoff) !== Boolean(reviewHandoff)) {
+        throw new LocalAuthoritativeTaskStatusError('Authoritative review handoff presence is invalid.');
+    }
+    let reviewCommentsPayload = null;
+    let reviewCommentActivity = null;
+    let reviewCommentTimestamp = null;
+    if (requestedReviewHandoff && reviewHandoff) {
+        reviewCommentsPayload = serializeWorkspaceSyncV3TaskCommentsPayload({
+            taskId: task.id,
+            comments: reviewHandoff.comments.payload.comments,
+        });
+        reviewCommentActivity = reviewHandoff.activity;
+        const requestedComment = requestedReviewHandoff.comment;
+        const authoritativeComment = reviewCommentsPayload.comments.find((comment) => comment.id === requestedComment.id);
+        reviewCommentTimestamp = authoritativeComment?.timestamp || null;
+        const expectedActivityId = buildTaskCommentActivityEventId({
+            workspaceId: input.identity.workspaceId,
+            clientId: input.identity.clientId,
+            operationId: input.identity.operationId,
+            taskId: task.id,
+            commentId: requestedComment.id,
+        });
+        const reviewCommentActivityDetails = reviewCommentActivity.details;
+        if (reviewHandoff.comments.domain !== 'task-comments'
+            || reviewHandoff.comments.entityId !== task.id
+            || reviewHandoff.comments.mutationKind !== 'append'
+            || !/^(0|[1-9]\d*)$/.test(reviewHandoff.comments.sequence)
+            || !/^(0|[1-9]\d*)$/.test(reviewHandoff.comments.entityRevision)
+            || reviewHandoff.comments.lifecycleRevision !== '0'
+            || reviewCommentsPayload.taskId !== task.id
+            || !authoritativeComment
+            || authoritativeComment.author !== requestedComment.author
+            || authoritativeComment.submittedAuthor !== requestedComment.submittedAuthor
+            || authoritativeComment.text !== requestedComment.text
+            || !isCanonicalIso(authoritativeComment.timestamp)
+            || reviewCommentActivity.id !== expectedActivityId
+            || reviewCommentActivity.workspaceId !== input.identity.workspaceId
+            || reviewCommentActivity.entityType !== 'task'
+            || reviewCommentActivity.entityId !== task.id
+            || reviewCommentActivity.taskId !== task.id
+            || reviewCommentActivity.action !== 'task-comment-added'
+            || !String(reviewCommentActivity.actor || '').trim()
+            || !['human', 'ai', 'system'].includes(reviewCommentActivity.actorType)
+            || reviewCommentActivity.createdAt !== task.updatedAt
+            || !reviewCommentActivityDetails
+            || Object.keys(reviewCommentActivityDetails).sort().join(',') !== 'commentId,preview,submittedAuthor'
+            || reviewCommentActivityDetails.commentId !== authoritativeComment.id
+            || reviewCommentActivityDetails.submittedAuthor !== authoritativeComment.submittedAuthor
+            || reviewCommentActivityDetails.preview !== authoritativeComment.text.slice(0, 160)
+            || reviewHandoff.activityRevision.domain !== 'entity-event'
+            || reviewHandoff.activityRevision.entityId !== expectedActivityId
+            || !/^(0|[1-9]\d*)$/.test(reviewHandoff.activityRevision.sequence)
+            || reviewHandoff.activityRevision.entityRevision !== '1'
+            || reviewHandoff.activityRevision.lifecycleRevision !== '0'
+            || canonicalWorkspaceSyncJson(reviewCommentsPayload) !== canonicalWorkspaceSyncJson(serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: task.id, comments: task.comments || [] }))) {
+            throw new LocalAuthoritativeTaskStatusError('Authoritative review handoff is invalid.');
+        }
+    }
     const requestedWorkflowAssignment = operationPayload.workflowAssignment || null;
     const workflowIdentityMismatch = (expected, actual) => expected.template.id !== actual.template.id
         || expected.version.id !== actual.version.id
@@ -269,7 +411,7 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
             || activity.taskId !== task.id
             || activity.action !== 'task-status-changed'
             || !isCanonicalIso(activity.createdAt)
-            || activity.createdAt !== task.updatedAt
+            || activity.createdAt !== (reviewCommentTimestamp || task.updatedAt)
             || typeof activity.actor !== 'string' || !activity.actor.trim()
             || !['human', 'ai', 'system'].includes(activity.actorType)
             || !activity.details || typeof activity.details !== 'object' || Array.isArray(activity.details)
@@ -279,12 +421,37 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
             throw new LocalAuthoritativeTaskStatusError('Authoritative task status activity is invalid.');
         }
     }
-    const revision = validateTaskActivityAuthoritativeRevision({
-        response: response,
-        authoritative: authoritative,
-        activityId: activity?.id || null,
-        invalid: (message) => new LocalAuthoritativeTaskStatusError(message),
-    });
+    const reviewIntermediateRevisions = reviewHandoff ? [
+        { sequence: reviewHandoff.comments.sequence },
+        { sequence: reviewHandoff.activityRevision.sequence },
+    ] : [];
+    const revision = activity === null && reviewHandoff
+        ? (() => {
+            const taskSequence = authoritative.sequence;
+            const commentsSequence = reviewHandoff.comments.sequence;
+            const commentActivitySequence = reviewHandoff.activityRevision.sequence;
+            if (!/^(0|[1-9]\d*)$/.test(taskSequence)
+                || BigInt(commentsSequence) !== BigInt(taskSequence) + 1n
+                || BigInt(commentActivitySequence) !== BigInt(commentsSequence) + 1n
+                || response.operationHighWatermark !== commentActivitySequence
+                || response.dependentActivityRevisions !== undefined) {
+                throw new LocalAuthoritativeTaskStatusError('Authoritative review handoff revisions are not in canonical sequence order.');
+            }
+            return {
+                taskSequence,
+                operationHighWatermark: commentActivitySequence,
+                activityRevision: null,
+                legacySingleEntry: false,
+                dependentActivityRevisions: [],
+            };
+        })()
+        : validateTaskActivityAuthoritativeRevision({
+            response: response,
+            authoritative: authoritative,
+            activityId: activity?.id || null,
+            invalid: (message) => new LocalAuthoritativeTaskStatusError(message),
+            intermediateRevisions: reviewIntermediateRevisions,
+        });
     const dependentActivities = Array.isArray(response.dependentActivities)
         ? response.dependentActivities
         : [];
@@ -373,7 +540,23 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
                 canonicalFingerprint,
                 metadataOwned: authoritative.metadataOwned,
                 reopenAssigneeOwned: authoritative.assigneeOwned,
-            }, ...(!revision.legacySingleEntry && revision.activityRevision && activity ? [{
+            }, ...(reviewHandoff && reviewCommentsPayload && reviewCommentActivity ? [{
+                    domain: 'task-comments',
+                    entityId: task.id,
+                    mutationKind: 'append',
+                    entityRevision: reviewHandoff.comments.entityRevision,
+                    lifecycleRevision: reviewHandoff.comments.lifecycleRevision,
+                    sequence: reviewHandoff.comments.sequence,
+                    canonicalFingerprint: fingerprintWorkspaceSyncPayload(reviewCommentsPayload),
+                }, {
+                    domain: WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN,
+                    entityId: reviewCommentActivity.id,
+                    mutationKind: WORKSPACE_SYNC_ENTITY_EVENT_APPEND,
+                    entityRevision: reviewHandoff.activityRevision.entityRevision,
+                    lifecycleRevision: reviewHandoff.activityRevision.lifecycleRevision,
+                    sequence: reviewHandoff.activityRevision.sequence,
+                    canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(reviewCommentActivity)),
+                }] : []), ...(!revision.legacySingleEntry && revision.activityRevision && activity ? [{
                     domain: WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN,
                     entityId: activity.id,
                     mutationKind: WORKSPACE_SYNC_ENTITY_EVENT_APPEND,
@@ -405,6 +588,30 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
                 : input.core.installDurableTaskStatusAuthoritativeForSync(task, payload, installAssignee, input.identity.workspaceId);
             if (!updated)
                 throw new LocalAuthoritativeTaskStatusError('Local task status projection is missing.');
+            if (reviewHandoff && reviewCommentsPayload && reviewCommentActivity) {
+                const localComments = serializeWorkspaceSyncV3TaskCommentsPayload({
+                    taskId: updated.id,
+                    comments: updated.comments || [],
+                });
+                const installedComments = hasSuccessor
+                    ? mergeWorkspaceSyncV3TaskCommentsPayload({
+                        taskId: updated.id,
+                        left: reviewCommentsPayload.comments,
+                        right: localComments.comments.filter((comment) => (!reviewCommentsPayload.comments.some((accepted) => accepted.id === comment.id))),
+                    })
+                    : reviewCommentsPayload;
+                updated = input.core.updateTask(task.id, { comments: installedComments.comments }, input.identity.workspaceId, {
+                    persistBackup: false,
+                    emitRealtime: false,
+                    skipTaskEvents: true,
+                    syncUpdatedAt: updated.updatedAt,
+                    allowV3OwnedMetadataWrite: true,
+                });
+                if (!updated)
+                    throw new LocalAuthoritativeTaskStatusError('Review handoff task disappeared locally.');
+                input.core.upsertEntityEventForSync(reviewCommentActivity, { allowAuthoritativeReplacement: true });
+                activityReconciled = true;
+            }
             if (hasSuccessor
                 && installAssignee
                 && !successors.some((successor) => successor.ownsTaskAssignee)

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

@@ -91,6 +91,15 @@ export type WorkspaceSyncOutboxRecord = WorkspaceSyncOperationIdentity & {
     leaseOwner: string | null;
     leaseExpiresAt: string | null;
 };
+export type WorkspaceSyncOutboxOperationLookup = WorkspaceSyncOperationIdentity & {
+    status: string;
+    createdAt: string;
+    domain: string;
+    entityId: string;
+    mutationKind: string;
+    payloadFingerprint: string;
+    authoritativeResponseJson: string | null;
+};
 export type WorkspaceSyncOutboxSupersession = {
     recoveryBatchId: string;
     operationIds: string[];
@@ -325,6 +334,31 @@ export declare class WorkspaceSyncDurabilityStore {
         createdAt: string;
     } | null;
     readOutboxOperation(identity: WorkspaceSyncOperationIdentity): WorkspaceSyncOutboxRecord | null;
+    assertOutboxOperationIdentity(record: Readonly<WorkspaceSyncOutboxRecord>, expected: {
+        domain: string;
+        entityId: string;
+        mutationKind: string;
+        payloadFingerprint?: string;
+    }): void;
+    readOutboxOperationLookup(identity: WorkspaceSyncOperationIdentity): WorkspaceSyncOutboxOperationLookup | null;
+    pruneTerminalOutboxOperations(input: {
+        tenantId: string;
+        workspaceId: string;
+        terminalBefore: string;
+        limit?: number;
+    }): {
+        deleted: number;
+        remainingEligible: number;
+    };
+    pruneCommittedOperationResults(input: {
+        tenantId: string;
+        workspaceId: string;
+        terminalBefore: string;
+        limit?: number;
+    }): {
+        deleted: number;
+        remainingEligible: number;
+    };
     readV3DispatchSettlementEvidence(identity: WorkspaceSyncOperationIdentity): WorkspaceSyncV3DispatchSettlementEvidence | null;
     listBlockedInvalidOutboxOperations(input: {
         tenantId: string;

package/dist/sync/v3/syncDurabilityStore.js

@@ -11,6 +11,7 @@ import { WorkspaceSyncJournalReader } from './workspaceSyncJournalReader.js';
 import { isLegacyEntityEventAdoptionIdentity, LEGACY_ENTITY_EVENT_ADOPTION_MAX_PAYLOAD_BYTES, } from './entityEventLegacyAdoptionContract.js';
 import { validateWorkspaceSyncV3EntityEventPayload } from './workspaceSyncV3NestedTaskCodecs.js';
 import { fingerprintWorkspaceSyncPayload } from './workspaceSyncPayloadFingerprint.js';
+import { assertDurableOperationFingerprint, assertDurableOperationIdentity, DurableOperationReplayIdentityConflictError, } from './durableOperationReplay.js';
 export { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 export { fingerprintWorkspaceSyncPayload } from './workspaceSyncPayloadFingerprint.js';
 export const WORKSPACE_SYNC_CONTRACT_VERSION = 3;
@@ -800,6 +801,130 @@ export class WorkspaceSyncDurabilityStore {
         `).get(...operationParams(identity));
         return row ? this.mapOutboxRow(row) : null;
     }
+    assertOutboxOperationIdentity(record, expected) {
+        assertDurableOperationIdentity({
+            operationId: record.operationId,
+            domain: record.domain,
+            entityId: record.entityId,
+            mutationKind: record.mutationKind,
+            payloadFingerprint: record.payloadFingerprint,
+        }, {
+            operationId: record.operationId,
+            domain: expected.domain,
+            entityId: expected.entityId,
+            mutationKind: expected.mutationKind,
+            payloadFingerprint: expected.payloadFingerprint || record.payloadFingerprint,
+        });
+    }
+    readOutboxOperationLookup(identity) {
+        const row = this.db.prepare(`
+            SELECT status, authoritative_response_json, created_at,
+                   mutation_kind, payload_fingerprint, domain, entity_id
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+            LIMIT 1
+        `).get(...operationParams(identity));
+        if (!row)
+            return null;
+        return {
+            ...identity,
+            status: requireText(row.status, 'Outbox status'),
+            createdAt: requireIsoTimestamp(row.created_at, 'Outbox creation time'),
+            domain: requireText(row.domain, 'Outbox domain'),
+            entityId: requireText(row.entity_id, 'Outbox entity id'),
+            mutationKind: requireText(row.mutation_kind, 'Outbox mutation kind'),
+            payloadFingerprint: requireText(row.payload_fingerprint, 'Outbox payload fingerprint'),
+            authoritativeResponseJson: row.authoritative_response_json == null
+                ? null
+                : requireText(row.authoritative_response_json, 'Outbox authoritative response'),
+        };
+    }
+    pruneTerminalOutboxOperations(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const terminalBefore = requireIsoTimestamp(input.terminalBefore, 'Operation retention cutoff');
+        const limit = Math.max(1, Math.min(1_000, Math.floor(input.limit ?? 100)));
+        const eligibility = `
+            candidate.tenant_id = ? AND candidate.workspace_id = ?
+            AND candidate.status IN ('accepted', 'superseded')
+            AND candidate.updated_at < ?
+            AND NOT EXISTS (
+                SELECT 1
+                FROM workspace_sync_outbox AS replay
+                WHERE replay.tenant_id = candidate.tenant_id
+                  AND replay.workspace_id = candidate.workspace_id
+                  AND replay.replay_of_client_id = candidate.client_id
+                  AND replay.replay_of_operation_id = candidate.operation_id
+            )
+        `;
+        return this.db.transaction(() => {
+            const candidates = this.db.prepare(`
+                SELECT candidate.client_id, candidate.operation_id
+                FROM workspace_sync_outbox AS candidate
+                WHERE ${eligibility}
+                ORDER BY candidate.updated_at, candidate.client_id, candidate.operation_id
+                LIMIT ?
+            `).all(tenantId, workspaceId, terminalBefore, limit);
+            let deleted = 0;
+            for (const candidate of candidates) {
+                const clientId = requireText(candidate.client_id, 'Retention client id');
+                const operationId = requireText(candidate.operation_id, 'Retention operation id');
+                const result = this.db.prepare(`
+                    DELETE FROM workspace_sync_outbox AS candidate
+                    WHERE ${eligibility}
+                      AND candidate.client_id = ? AND candidate.operation_id = ?
+                `).run(tenantId, workspaceId, terminalBefore, clientId, operationId);
+                if (Number(result.changes || 0) !== 1)
+                    continue;
+                this.db.prepare(`
+                    DELETE FROM workspace_sync_outbox_targets
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                `).run(tenantId, workspaceId, clientId, operationId);
+                deleted += 1;
+            }
+            const remaining = this.db.prepare(`
+                SELECT COUNT(*) AS count
+                FROM workspace_sync_outbox AS candidate
+                WHERE ${eligibility}
+            `).get(tenantId, workspaceId, terminalBefore);
+            return { deleted, remainingEligible: Number(remaining?.count || 0) };
+        })();
+    }
+    pruneCommittedOperationResults(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const terminalBefore = requireIsoTimestamp(input.terminalBefore, 'Operation retention cutoff');
+        const limit = Math.max(1, Math.min(1_000, Math.floor(input.limit ?? 100)));
+        return this.db.transaction(() => {
+            const candidates = this.db.prepare(`
+                SELECT client_id, operation_id
+                FROM workspace_sync_operation_results
+                WHERE tenant_id = ? AND workspace_id = ?
+                  AND status = 'committed' AND updated_at < ?
+                ORDER BY updated_at, client_id, operation_id
+                LIMIT ?
+            `).all(tenantId, workspaceId, terminalBefore, limit);
+            let deleted = 0;
+            for (const candidate of candidates) {
+                const clientId = requireText(candidate.client_id, 'Retention client id');
+                const operationId = requireText(candidate.operation_id, 'Retention operation id');
+                const result = this.db.prepare(`
+                    DELETE FROM workspace_sync_operation_results
+                    WHERE tenant_id = ? AND workspace_id = ?
+                      AND client_id = ? AND operation_id = ?
+                      AND status = 'committed' AND updated_at < ?
+                `).run(tenantId, workspaceId, clientId, operationId, terminalBefore);
+                deleted += Number(result.changes || 0);
+            }
+            const remaining = this.db.prepare(`
+                SELECT COUNT(*) AS count
+                FROM workspace_sync_operation_results
+                WHERE tenant_id = ? AND workspace_id = ?
+                  AND status = 'committed' AND updated_at < ?
+            `).get(tenantId, workspaceId, terminalBefore);
+            return { deleted, remainingEligible: Number(remaining?.count || 0) };
+        })();
+    }
     readV3DispatchSettlementEvidence(identity) {
         const row = this.db.prepare(`
             SELECT outbox.status, outbox.authoritative_response_json,
@@ -2457,9 +2582,15 @@ export class WorkspaceSyncDurabilityStore {
             })()
             : null;
         const taskAggregateRootTarget = additionalTargets[0];
+        const queueableTaskReviewHandoff = domain === 'task'
+            && mutationKind === 'set-status'
+            && additionalTargets.length === 1
+            && taskAggregateRootTarget.domain === 'task-comments'
+            && taskAggregateRootTarget.entityId === entityId
+            && taskAggregateRootTarget.mutationKind === 'append';
         const queueableTaskRoot = domain === 'task'
             && TASK_ROOT_SUCCESSOR_MUTATIONS.has(mutationKind)
-            && additionalTargets.length === 0;
+            && (additionalTargets.length === 0 || queueableTaskReviewHandoff);
         const queueableTaskAggregate = Boolean(TASK_AGGREGATE_SUCCESSOR_MUTATIONS.get(domain)?.has(mutationKind))
             && ((domain === 'task-comments' && mutationKind === 'reconcile' && additionalTargets.length === 0)
                 || (additionalTargets.length === 1
@@ -2786,6 +2917,32 @@ export class WorkspaceSyncDurabilityStore {
                 FROM workspace_sync_outbox
                 WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
             `).get(...ids);
+            if (existing) {
+                try {
+                    const existingPayloadFingerprint = String(existing.payload_fingerprint || '');
+                    assertDurableOperationIdentity({
+                        operationId: ids[3],
+                        domain: String(existing.domain || ''),
+                        entityId: String(existing.entity_id || ''),
+                        mutationKind: String(existing.mutation_kind || ''),
+                        payloadFingerprint: existingPayloadFingerprint,
+                    }, {
+                        operationId: ids[3],
+                        domain,
+                        entityId,
+                        mutationKind,
+                        payloadFingerprint: existingPayloadFingerprint === coalescedWorkflowPayloadFingerprint
+                            ? coalescedWorkflowPayloadFingerprint
+                            : payloadFingerprint,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof DurableOperationReplayIdentityConflictError) {
+                        throw new WorkspaceSyncIdempotencyConflictError();
+                    }
+                    throw error;
+                }
+            }
             const matches = existing
                 && Number(existing.contract_version) === WORKSPACE_SYNC_CONTRACT_VERSION
                 && existing.dispatch_class === dispatchClass
@@ -4715,9 +4872,18 @@ export class WorkspaceSyncDurabilityStore {
     assertMatchingOperation(row, requestFingerprint) {
         if (!row)
             throw new Error('Workspace sync operation does not exist.');
-        if (Number(row.contract_version) !== WORKSPACE_SYNC_CONTRACT_VERSION || row.request_fingerprint !== requestFingerprint) {
+        if (Number(row.contract_version) !== WORKSPACE_SYNC_CONTRACT_VERSION) {
             throw new WorkspaceSyncIdempotencyConflictError();
         }
+        try {
+            assertDurableOperationFingerprint(String(row.request_fingerprint || ''), requestFingerprint);
+        }
+        catch (error) {
+            if (error instanceof DurableOperationReplayIdentityConflictError) {
+                throw new WorkspaceSyncIdempotencyConflictError();
+            }
+            throw error;
+        }
     }
     mapOutboxRow(row) {
         return {

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

@@ -52,6 +52,16 @@ export type DurableTaskChecklistMutationResult = {
     responseJson: string;
     response: DurableTaskChecklistResponse;
 };
+export type TaskChecklistItemUpdateIntent = {
+    kind: 'item-update';
+    itemId: string;
+    patch: {
+        text?: string;
+        done?: boolean;
+        order?: number;
+    };
+};
+export declare function validateTaskChecklistItemUpdateIntent(value: unknown): TaskChecklistItemUpdateIntent;
 export interface DurableTaskChecklistServiceCore {
     getTask(id: string, workspaceId?: string): TaskItem | null;
     updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
@@ -89,6 +99,7 @@ export declare function runDurableTaskChecklistReplace(input: {
     resolveActorRef?: () => string;
     originActorRef?: string;
     expectedDetailRevision?: string;
+    itemUpdateIntent?: TaskChecklistItemUpdateIntent;
     assertPrecondition?: () => void;
     onPostCommitError?: (error: unknown) => void;
 }): DurableTaskChecklistMutationResult;