@taskforcehq/taskforce 0.3.329 → 0.3.330

package/dist/sync/v3/taskChecklistMutationService.js

@@ -22,6 +22,37 @@ export class DurableTaskChecklistMutationError extends Error {
         this.name = 'DurableTaskChecklistMutationError';
     }
 }
+export function validateTaskChecklistItemUpdateIntent(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new DurableTaskChecklistMutationError('Task checklist item update intent is invalid.', 'TASK_CHECKLIST_INVALID', 400);
+    }
+    const source = value;
+    const patch = source.patch;
+    if (source.kind !== 'item-update'
+        || Object.keys(source).some((key) => key !== 'kind' && key !== 'itemId' && key !== 'patch')
+        || typeof source.itemId !== 'string' || !source.itemId.trim()
+        || !patch || typeof patch !== 'object' || Array.isArray(patch)) {
+        throw new DurableTaskChecklistMutationError('Task checklist item update intent is invalid.', 'TASK_CHECKLIST_INVALID', 400);
+    }
+    const patchSource = patch;
+    if (Object.keys(patchSource).some((key) => key !== 'text' && key !== 'done' && key !== 'order')
+        || Object.keys(patchSource).length === 0
+        || (patchSource.text !== undefined && (typeof patchSource.text !== 'string' || !patchSource.text.trim()))
+        || (patchSource.done !== undefined && typeof patchSource.done !== 'boolean')
+        || (patchSource.order !== undefined
+            && (!Number.isInteger(patchSource.order) || Number(patchSource.order) < 0))) {
+        throw new DurableTaskChecklistMutationError('Task checklist item update intent is invalid.', 'TASK_CHECKLIST_INVALID', 400);
+    }
+    return {
+        kind: 'item-update',
+        itemId: source.itemId.trim(),
+        patch: {
+            ...(patchSource.text !== undefined ? { text: patchSource.text.trim() } : {}),
+            ...(patchSource.done !== undefined ? { done: patchSource.done } : {}),
+            ...(patchSource.order !== undefined ? { order: Number(patchSource.order) } : {}),
+        },
+    };
+}
 function canonicalItems(taskId, items) {
     try {
         return serializeWorkspaceSyncV3TaskChecklistPayload({ taskId, items }).items;
@@ -46,6 +77,18 @@ function revision(revisions, domain) {
 }
 export function runDurableTaskChecklistReplace(input) {
     const items = canonicalItems(input.taskId, input.items);
+    const itemUpdateIntent = input.itemUpdateIntent
+        ? validateTaskChecklistItemUpdateIntent(input.itemUpdateIntent)
+        : undefined;
+    if (itemUpdateIntent) {
+        const target = items.find((item) => item.id === itemUpdateIntent.itemId);
+        if (!target
+            || (itemUpdateIntent.patch.text !== undefined && target.title !== itemUpdateIntent.patch.text)
+            || (itemUpdateIntent.patch.done !== undefined && target.isCompleted !== itemUpdateIntent.patch.done)
+            || (itemUpdateIntent.patch.order !== undefined && target.order !== itemUpdateIntent.patch.order)) {
+            throw new DurableTaskChecklistMutationError('Task checklist item update intent does not match the replacement aggregate.', 'TASK_CHECKLIST_INVALID', 400);
+        }
+    }
     const identity = {
         tenantId: input.tenantId, workspaceId: input.workspaceId, clientId: input.clientId, operationId: input.operationId,
     };
@@ -56,7 +99,7 @@ export function runDurableTaskChecklistReplace(input) {
             domain: 'task-checklist', entityId: input.taskId, mutationKind: 'replace',
             baseEntityRevision: String(input.baseEntityRevision),
             baseLifecycleRevision: String(input.baseLifecycleRevision),
-            items,
+            ...(itemUpdateIntent ? { itemUpdateIntent } : { items }),
             ...(input.originActorRef ? { originActorRef: input.originActorRef } : {}),
             ...(input.expectedDetailRevision
                 ? { expectedDetailRevision: input.expectedDetailRevision }

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

@@ -1,4 +1,4 @@
-import type { EntityEvent, TaskEvent } from '../../core/Taskforce.js';
+import type { Comment, EntityEvent, TaskEvent } from '../../core/Taskforce.js';
 import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
 import type { TaskActor } from '../../types.js';
 import { type DurableTaskStatusMutationCore } from '../../core/TaskDurableStatusMutationService.js';
@@ -6,6 +6,7 @@ import { serializeTaskForSync } from '../taskSyncPayload.js';
 import type { WorkflowAssignmentSyncRecord } from '../../storage/workflowStore.js';
 import { type WorkspaceSyncActivityRevision } from './taskActivityJournal.js';
 import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+import { type WorkspaceSyncV3TaskCommentsPayload } from './workspaceSyncV3NestedTaskCodecs.js';
 export interface DurableTaskStatusServiceCore extends DurableTaskStatusMutationCore {
     notifyDurableTaskLifecycleCommitted(workspaceId: string, taskId: string): void;
     getTaskEventForSync(input: {
@@ -19,6 +20,14 @@ export interface DurableTaskStatusServiceCore extends DurableTaskStatusMutationC
     }): EntityEvent | null;
     listAssignableActors(workspaceId: string): TaskActor[];
     getDatabaseAdapter(): DatabaseAdapter;
+    addTaskCommentEventForDurableSync(event: {
+        taskId: string;
+        workspaceId: string;
+        actor: string;
+        eventId: string;
+        createdAt: string;
+        comment: Comment;
+    }): void;
 }
 export type DurableTaskStatusResponse = {
     success: true;
@@ -45,7 +54,25 @@ export type DurableTaskStatusResponse = {
     dependentActivities?: EntityEvent[];
     dependentActivityRevisions?: WorkspaceSyncActivityRevision[];
     workflowAssignment?: WorkflowAssignmentSyncRecord;
+    reviewHandoff?: {
+        comments: {
+            domain: 'task-comments';
+            entityId: string;
+            mutationKind: 'append';
+            sequence: string;
+            entityRevision: string;
+            lifecycleRevision: string;
+            payload: WorkspaceSyncV3TaskCommentsPayload;
+        };
+        activity: TaskEvent;
+        activityRevision: WorkspaceSyncActivityRevision;
+    };
 };
+export declare class WorkflowRuntimeActivationFencedError extends Error {
+    readonly code = "WORKFLOW_RUNTIME_MUTATIONS_FENCED";
+    readonly statusCode = 503;
+    constructor();
+}
 export declare function runDurableTaskStatusMutation(input: {
     store: WorkspaceSyncDurabilityStore;
     core: DurableTaskStatusServiceCore;
@@ -64,6 +91,7 @@ export declare function runDurableTaskStatusMutation(input: {
     resolveActorRef?: () => string;
     originActorRef?: string;
     includeWorkflowRuntimeJournal?: boolean;
+    rejectWorkflowRuntimeActivation?: boolean;
     expectedDetailRevision?: string;
     assertPrecondition?: () => void;
     onPostCommitError?: (error: unknown) => void;

package/dist/sync/v3/taskStatusMutationService.js

@@ -8,7 +8,27 @@ import { asWorkspaceSyncActivityRevision, buildEntityActivityJournalEntry, build
 import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
 import { resolveDeferredMutationActorRef } from './workspaceSyncV3OriginActor.js';
 import { buildWorkflowRuntimeEventId } from './workflowRuntimeOperationIdentity.js';
+import { buildTaskCommentActivityEventId } from './taskCommentActivityIdentity.js';
+import { serializeWorkspaceSyncV3TaskCommentAppendPayload, serializeWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
 import { fingerprintWorkflowRuntimePayload, serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, serializeWorkflowPublishedDefinitionSyncPayload, } from './workflowRuntimeSync.js';
+export class WorkflowRuntimeActivationFencedError extends Error {
+    code = 'WORKFLOW_RUNTIME_MUTATIONS_FENCED';
+    statusCode = 503;
+    constructor() {
+        super('Workflow execution changes are temporarily paused.');
+        this.name = 'WorkflowRuntimeActivationFencedError';
+    }
+}
+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 Error('Task status operation timestamp is invalid.');
+    }
+    return Number.isFinite(currentMs) && currentMs >= requestedMs
+        ? new Date(currentMs + 1).toISOString()
+        : requested;
+}
 export function runDurableTaskStatusMutation(input) {
     const operationPayload = normalizeTaskStatusOperationWithWorkflowAssignment(input.payload);
     const payload = validateDurableTaskStatusMutationPayload({
@@ -48,10 +68,24 @@ export function runDurableTaskStatusMutation(input) {
     });
     const membershipRemovedEventId = `${activityEventId}:workstream-removed`;
     const membershipAddedEventId = `${activityEventId}:workstream-added`;
+    const requestedReviewComment = operationPayload.reviewHandoff?.comment || null;
+    let reviewComment = null;
+    const reviewCommentActivityEventId = requestedReviewComment ? buildTaskCommentActivityEventId({
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+        taskId: input.taskId,
+        commentId: requestedReviewComment.id,
+    }) : null;
     const workflowStore = new WorkflowStore(input.core.getDatabaseAdapter(), input.tenantId);
     const workflowActivationService = new WorkflowTaskActivationService(workflowStore, (workspaceId) => input.core.listAssignableActors(workspaceId));
     const pendingAssignment = operationPayload.workflowAssignment
         || workflowStore.getAssignmentForTaskSync(input.workspaceId, input.taskId);
+    if (input.rejectWorkflowRuntimeActivation === true
+        && payload.status === 'in-progress'
+        && pendingAssignment?.execution.status === 'pending') {
+        throw new WorkflowRuntimeActivationFencedError();
+    }
     const workflowStartEventId = buildWorkflowRuntimeEventId({
         workspaceId: input.workspaceId,
         clientId: input.clientId,
@@ -95,6 +129,16 @@ export function runDurableTaskStatusMutation(input) {
             throw new Error('Task status activity was not committed.');
         return activity;
     };
+    const readReviewCommentActivity = () => {
+        const activity = input.core.getTaskEventForSync({
+            workspaceId: input.workspaceId,
+            taskId: input.taskId,
+            eventId: reviewCommentActivityEventId,
+        });
+        if (!activity)
+            throw new Error('Review handoff comment activity was not committed.');
+        return activity;
+    };
     const workflowAssignmentAfterMutation = () => {
         const assignment = workflowStore.getAssignmentForTaskSync(input.workspaceId, input.taskId);
         if (!assignment || assignment.execution.id !== pendingAssignment?.execution.id) {
@@ -158,7 +202,22 @@ export function runDurableTaskStatusMutation(input) {
                 reopenAssigneeOwned: (result) => result.assigneeOwned,
                 buildCanonicalFingerprint: (result) => (fingerprintWorkspaceSyncPayload(serializeTaskForSync(result.task))),
                 buildAuthoritativePayload: (result) => serializeTaskForSync(result.task),
-            }, {
+            }, ...(requestedReviewComment ? [{
+                    domain: 'task-comments', entityId: input.taskId, mutationKind: 'append', revisionKind: 'metadata',
+                    baseEntityRevision: 0, baseLifecycleRevision: 0, baseRevisionPolicy: 'current',
+                    buildCanonicalFingerprint: (result) => fingerprintWorkspaceSyncPayload(serializeWorkspaceSyncV3TaskCommentsPayload({
+                        taskId: result.task.id,
+                        comments: result.task.comments || [],
+                    })),
+                    buildAuthoritativePayload: (result) => (serializeWorkspaceSyncV3TaskCommentAppendPayload({
+                        taskId: result.task.id,
+                        comment: reviewComment,
+                        commentsAfterAppend: result.task.comments || [],
+                    })),
+                }, buildTaskActivityJournalEntry({
+                    eventId: reviewCommentActivityEventId,
+                    readEvent: readReviewCommentActivity,
+                })] : []), {
                 ...buildTaskActivityJournalEntry({ eventId: activityEventId, readEvent: readActivity }),
                 include: (result) => !result.noOp,
             }, {
@@ -208,7 +267,7 @@ export function runDurableTaskStatusMutation(input) {
                 })
                 : null;
             const actorRef = resolveDeferredMutationActorRef(input);
-            const result = applyTaskStatusMutationForDurableSync({
+            let result = applyTaskStatusMutationForDurableSync({
                 core: input.core,
                 workspaceId: input.workspaceId,
                 taskId: input.taskId,
@@ -224,6 +283,42 @@ export function runDurableTaskStatusMutation(input) {
                 actorRef,
                 taskEventId: activityEventId,
             });
+            if (requestedReviewComment) {
+                const authoritativeReviewComment = {
+                    ...requestedReviewComment,
+                    author: actorRef,
+                    submittedAuthor: actorRef,
+                    timestamp: input.now,
+                };
+                reviewComment = authoritativeReviewComment;
+                const existingComments = serializeWorkspaceSyncV3TaskCommentsPayload({
+                    taskId: result.task.id,
+                    comments: result.task.comments || [],
+                }).comments;
+                const collision = existingComments.find((comment) => comment.id === authoritativeReviewComment.id);
+                if (collision) {
+                    throw new Error(`Review handoff comment identity conflict: ${authoritativeReviewComment.id}.`);
+                }
+                const updatedAt = nextTaskUpdatedAt(String(result.task.updatedAt || result.task.createdAt), input.now);
+                const updated = input.core.updateTask(result.task.id, { comments: [...existingComments, authoritativeReviewComment] }, input.workspaceId, {
+                    persistBackup: false,
+                    emitRealtime: false,
+                    skipTaskEvents: true,
+                    syncUpdatedAt: updatedAt,
+                    allowV3OwnedMetadataWrite: true,
+                });
+                if (!updated)
+                    throw new Error('Review handoff task disappeared during comment persistence.');
+                input.core.addTaskCommentEventForDurableSync({
+                    taskId: updated.id,
+                    workspaceId: input.workspaceId,
+                    actor: actorRef,
+                    eventId: reviewCommentActivityEventId,
+                    createdAt: String(updated.updatedAt),
+                    comment: authoritativeReviewComment,
+                });
+                result = { ...result, task: updated };
+            }
             if (activation) {
                 workflowActivationService.start({
                     workspaceId: input.workspaceId,
@@ -261,6 +356,9 @@ export function runDurableTaskStatusMutation(input) {
                     throw new Error('Dependent task status activity was not committed.');
                 return event;
             });
+            const reviewCommentsRevision = reviewComment ? revisions.find((revision) => (revision.domain === 'task-comments' && revision.entityId === input.taskId)) : null;
+            const reviewActivityRevisionValue = reviewComment ? revisions.find((revision) => (revision.domain === 'entity-event' && revision.entityId === reviewCommentActivityEventId)) : null;
+            const reviewActivity = reviewComment ? readReviewCommentActivity() : null;
             return {
                 success: true,
                 contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
@@ -285,6 +383,24 @@ export function runDurableTaskStatusMutation(input) {
                 activityRevision,
                 ...(dependentActivities.length > 0 ? { dependentActivities } : {}),
                 ...(dependentActivityRevisions.length > 0 ? { dependentActivityRevisions } : {}),
+                ...(reviewComment && reviewCommentsRevision && reviewActivityRevisionValue && reviewActivity ? {
+                    reviewHandoff: {
+                        comments: {
+                            domain: 'task-comments',
+                            entityId: result.task.id,
+                            mutationKind: 'append',
+                            sequence: reviewCommentsRevision.sequence,
+                            entityRevision: reviewCommentsRevision.entityRevision,
+                            lifecycleRevision: reviewCommentsRevision.lifecycleRevision,
+                            payload: serializeWorkspaceSyncV3TaskCommentsPayload({
+                                taskId: result.task.id,
+                                comments: result.task.comments || [],
+                            }),
+                        },
+                        activity: reviewActivity,
+                        activityRevision: asWorkspaceSyncActivityRevision(reviewActivityRevisionValue),
+                    },
+                } : {}),
                 ...(workflowStore.getAssignmentForTaskSync(input.workspaceId, result.task.id)
                     ? { workflowAssignment: workflowStore.getAssignmentForTaskSync(input.workspaceId, result.task.id) }
                     : {}),
@@ -292,7 +408,7 @@ export function runDurableTaskStatusMutation(input) {
         },
     });
     const response = JSON.parse(accepted.responseJson);
-    if (response.activity) {
+    if (response.activity || response.reviewHandoff) {
         try {
             input.core.notifyDurableTaskLifecycleCommitted(input.workspaceId, input.taskId);
         }

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

@@ -1,8 +1,13 @@
 import type { WorkflowAssignmentSyncRecord, WorkflowExecutionEventRecord, WorkflowExecutionRecord, WorkflowStepRecord, WorkflowTemplateRecord, WorkflowVersionRecord } from '../../storage/workflowStore.js';
+import type { Comment } from '../../core/Taskforce.js';
 import { type DurableTaskStatusMutationPayload } from '../../core/TaskDurableStatusMutationService.js';
+export type TaskStatusReviewHandoff = {
+    comment: Pick<Comment, 'id' | 'author' | 'submittedAuthor' | 'text'>;
+};
 export type TaskStatusOperationWithWorkflowAssignment = DurableTaskStatusMutationPayload & {
     workflowAssignment?: WorkflowAssignmentSyncRecord;
     expectedDetailRevision?: string;
+    reviewHandoff?: TaskStatusReviewHandoff;
 };
 export declare class WorkflowAssignmentSyncError extends Error {
     readonly code = "WORKFLOW_ASSIGNMENT_SYNC_INVALID";

package/dist/sync/v3/workflowAssignmentSync.js

@@ -203,11 +203,38 @@ export function normalizeTaskStatusOperationWithWorkflowAssignment(raw) {
         }
         originActor = { kind: 'ai-profile', profileId };
     }
+    let reviewHandoff;
+    if (source.reviewHandoff !== undefined) {
+        if (status.status !== 'review') {
+            throw new WorkflowAssignmentSyncError('reviewHandoff is valid only when status is review.');
+        }
+        const handoff = object(source.reviewHandoff, 'reviewHandoff');
+        if (Object.keys(handoff).join(',') !== 'comment') {
+            throw new WorkflowAssignmentSyncError('reviewHandoff must contain exactly comment.');
+        }
+        const comment = object(handoff.comment, 'reviewHandoff.comment');
+        if (Object.keys(comment).sort().join(',') !== 'author,id,submittedAuthor,text') {
+            throw new WorkflowAssignmentSyncError('reviewHandoff.comment must contain exactly id, author, submittedAuthor, and text.');
+        }
+        const author = text(comment.author, 'reviewHandoff.comment.author');
+        const submittedAuthor = text(comment.submittedAuthor, 'reviewHandoff.comment.submittedAuthor');
+        const commentText = text(comment.text, 'reviewHandoff.comment.text');
+        if (author !== submittedAuthor) {
+            throw new WorkflowAssignmentSyncError('reviewHandoff comment authorship is invalid.');
+        }
+        reviewHandoff = { comment: {
+                id: text(comment.id, 'reviewHandoff.comment.id'),
+                author,
+                submittedAuthor,
+                text: commentText,
+            } };
+    }
     return {
         ...status,
         ...(source.workflowAssignment === undefined
             ? {}
             : { workflowAssignment: normalizeWorkflowAssignmentSyncRecord(source.workflowAssignment) }),
+        ...(reviewHandoff ? { reviewHandoff } : {}),
         ...(originActor ? { originActor } : {}),
         ...(typeof source.expectedDetailRevision === 'string' && source.expectedDetailRevision.trim()
             ? { expectedDetailRevision: source.expectedDetailRevision.trim() }

package/dist/sync/v3/workspaceSyncJournalReader.js

@@ -31,7 +31,7 @@ export class WorkspaceSyncJournalReader {
             CAST(lifecycle_revision AS TEXT) AS lifecycle_revision, content_sha256,
             CAST(size_bytes AS TEXT) AS size_bytes, payload_json, occurred_at FROM workspace_sync_journal
             WHERE tenant_id = ? AND workspace_id = ? AND sequence > ? AND sequence <= ?
-            ORDER BY sequence ASC LIMIT ?`).all(input.tenantId, input.workspaceId, sequence(input.afterSequence), sequence(input.throughSequence), Math.max(1, Math.min(10_101, Math.floor(input.limit))));
+            ORDER BY workspace_sync_journal.sequence ASC LIMIT ?`).all(input.tenantId, input.workspaceId, sequence(input.afterSequence), sequence(input.throughSequence), Math.max(1, Math.min(10_101, Math.floor(input.limit))));
         return rows.map((row) => ({
             sequence: sequence(row.sequence), contractVersion: Number(row.contract_version), clientId: String(row.client_id || ''),
             operationId: String(row.operation_id || ''), domain: String(row.domain || ''),

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

@@ -0,0 +1,16 @@
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_DAYS = 90;
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_INTERVAL_MS: number;
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE = 100;
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_WORKSPACE_LIMIT = 100;
+export interface WorkspaceSyncOperationRetentionResult {
+    deletedOutbox: number;
+    deletedResults: number;
+    remainingEligible: number;
+    workspacesProcessed: number;
+}
+export declare function pruneRetainedWorkspaceSyncOperations(input: {
+    db: DatabaseAdapter;
+    tenantId: string;
+    now?: Date;
+}): WorkspaceSyncOperationRetentionResult;

package/dist/sync/v3/workspaceSyncOperationRetentionService.js

@@ -0,0 +1,83 @@
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+export const WORKSPACE_SYNC_OPERATION_RETENTION_DAYS = 90;
+export const WORKSPACE_SYNC_OPERATION_RETENTION_INTERVAL_MS = 24 * 60 * 60_000;
+export const WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE = 100;
+export const WORKSPACE_SYNC_OPERATION_RETENTION_WORKSPACE_LIMIT = 100;
+export function pruneRetainedWorkspaceSyncOperations(input) {
+    const now = input.now || new Date();
+    const cutoff = new Date(now.getTime() - WORKSPACE_SYNC_OPERATION_RETENTION_DAYS * 24 * 60 * 60_000).toISOString();
+    const workspaceRows = input.db.prepare(`
+        SELECT eligible.workspace_id
+        FROM (
+            SELECT candidate.workspace_id, candidate.updated_at AS terminal_at
+            FROM workspace_sync_outbox AS candidate
+            WHERE candidate.tenant_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
+              )
+            UNION ALL
+            SELECT workspace_id, updated_at AS terminal_at
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND status = 'committed' AND updated_at < ?
+        ) AS eligible
+        GROUP BY eligible.workspace_id
+        ORDER BY MIN(eligible.terminal_at), eligible.workspace_id
+        LIMIT ?
+    `).all(input.tenantId, cutoff, input.tenantId, cutoff, WORKSPACE_SYNC_OPERATION_RETENTION_WORKSPACE_LIMIT);
+    const store = new WorkspaceSyncDurabilityStore(input.db);
+    let deletedOutbox = 0;
+    let deletedResults = 0;
+    for (const row of workspaceRows) {
+        const workspaceId = String(row.workspace_id || '').trim();
+        if (!workspaceId)
+            continue;
+        const outboxResult = store.pruneTerminalOutboxOperations({
+            tenantId: input.tenantId,
+            workspaceId,
+            terminalBefore: cutoff,
+            limit: WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE,
+        });
+        deletedOutbox += outboxResult.deleted;
+        const result = store.pruneCommittedOperationResults({
+            tenantId: input.tenantId,
+            workspaceId,
+            terminalBefore: cutoff,
+            limit: WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE,
+        });
+        deletedResults += result.deleted;
+    }
+    const remaining = input.db.prepare(`
+        SELECT (
+            SELECT COUNT(*)
+            FROM workspace_sync_outbox AS candidate
+            WHERE candidate.tenant_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
+              )
+        ) + (
+            SELECT COUNT(*)
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND status = 'committed' AND updated_at < ?
+        ) AS count
+    `).get(input.tenantId, cutoff, input.tenantId, cutoff);
+    return {
+        deletedOutbox,
+        deletedResults,
+        remainingEligible: Number(remaining?.count || 0),
+        workspacesProcessed: workspaceRows.length,
+    };
+}

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

@@ -46,6 +46,7 @@ export type WorkspaceSyncV3CloudOperationContext = {
     /** @deprecated Prefer resolveOriginActorRef; retained for create callers. */
     resolveTaskCreateActorRef?: (originActor: NonNullable<WorkspaceSyncV3TaskCreateEnvelope['operation']['payload']['originActor']>) => string;
     onPostCommitError?: (error: unknown) => void;
+    includeWorkflowRuntimeJournal?: boolean;
 };
 export type WorkspaceSyncV3CloudOperationHandler = {
     key: string;

package/dist/sync/v3/workspaceSyncV3CloudOperationHandler.js

@@ -197,6 +197,7 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
                     taskId: operation.entityId,
                     payload,
                     expectedDetailRevision,
+                    includeWorkflowRuntimeJournal: context.includeWorkflowRuntimeJournal,
                     assertPrecondition: expectedDetailRevision && context.core.assertTaskDetailRevisionForUpdate
                         ? () => context.core.assertTaskDetailRevisionForUpdate(operation.entityId, expectedDetailRevision, context.workspaceId)
                         : undefined,
@@ -237,10 +238,16 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
             supports: (envelope) => envelope.operation.domain === 'task-checklist' && envelope.operation.mutationKind === 'replace',
             apply: (envelope, context) => {
                 const operation = envelope.operation;
+                const { originActor, expectedDetailRevision, itemUpdateIntent, items } = operation.payload;
                 return runDurableTaskChecklistReplace({
-                    ...withDeferredOriginActor(context, operation.payload.originActor),
+                    ...withDeferredOriginActor(context, originActor),
                     taskId: operation.entityId,
-                    items: operation.payload.items,
+                    items,
+                    expectedDetailRevision,
+                    itemUpdateIntent,
+                    assertPrecondition: expectedDetailRevision && context.core.assertTaskDetailRevisionForUpdate
+                        ? () => context.core.assertTaskDetailRevisionForUpdate(operation.entityId, expectedDetailRevision, context.workspaceId)
+                        : undefined,
                     baseEntityRevision: operation.baseEntityRevision,
                     baseLifecycleRevision: operation.baseLifecycleRevision,
                 });

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

@@ -6,6 +6,7 @@ export declare function prepareWorkspaceSyncV3CombinedRepairSnapshot(input: {
     now?: string;
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
+    workflowTaskCoverCoverage?: boolean;
     planningOrderCoverage?: boolean;
     taskCoverCoverage?: boolean;
     coveredLegacyWritesFenced?: boolean;
@@ -42,6 +43,12 @@ export declare function prepareWorkspaceSyncV3TaskCoverRepairSnapshot(input: {
     now?: string;
     coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
+export declare function prepareWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+    coveredLegacyWritesFenced?: boolean;
+}): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function ensureWorkspaceSyncV3CombinedRepairBaselines(input: {
     core: TaskforceCore;
     workspaceId: string;