@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/sync/syncService.js

@@ -1,7 +1,7 @@
 import { applyLocalWorkspaceChanges, getLocalWorkspaceContentPullObligations, recordLocalWorkspaceContentPullObligationFailures, getLocalWorkspaceContentManifest, pullUserSettings, pushUserSettings, prepareWorkspacePushChanges, } from './cloudSyncApi.js';
 import { workspaceSyncContentPullObligationId, } from './engine/workspaceSyncContentPullObligationStore.js';
 import { createBrowserWorkspaceSyncEngineRemoteServices, } from './engine/workspaceSyncEngineRemoteServices.js';
-import { createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEngineAppliedTaskUpserts, workspaceSyncEngineExpectedTaskEchoIds, } from './engine/workspaceSyncEnginePushCompletion.js';
+import { createWorkspaceSyncEngineV2SettlementIdentityProjection, createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEngineAppliedTaskUpserts, workspaceSyncEngineExpectedTaskEchoIds, } from './engine/workspaceSyncEnginePushCompletion.js';
 import { encryptDocument } from './encryptionService.js';
 import { decryptWorkspaceSyncContentChangeInPlace } from './workspaceSyncContentDecryption.js';
 import { decideWorkspaceContentFetch, fingerprintWorkspaceContentBody, } from './workspaceContentManifest.js';
@@ -181,13 +181,8 @@ function buildEffectiveWorkspacePushDiagnostics(diagnostics, changes, ownership)
             : {}),
     };
 }
-async function computeIdempotencyKey(workspaceId, changes, repairMode) {
-    const text = canonicalWorkspaceSyncJson({
-        contractVersion: 1,
-        workspaceId,
-        repairMode,
-        changes
-    });
+async function computeCanonicalWorkspaceSyncSha256(value, fallbackNamespace) {
+    const text = canonicalWorkspaceSyncJson(value);
     try {
         const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
         return Array.from(new Uint8Array(buffer)).map(b => b.toString(16).padStart(2, '0')).join('');
@@ -202,9 +197,19 @@ async function computeIdempotencyKey(workspaceId, changes, repairMode) {
             hash = Math.imul(hash, 0x01000193);
         }
         const hex = (hash >>> 0).toString(16).padStart(8, '0');
-        return `${workspaceId}:fallback:${hex}`;
+        return fallbackNamespace
+            ? `${fallbackNamespace}:fallback:${hex}`
+            : hex.repeat(8);
     }
 }
+async function computeIdempotencyKey(workspaceId, changes, repairMode) {
+    return computeCanonicalWorkspaceSyncSha256({
+        contractVersion: 1,
+        workspaceId,
+        repairMode,
+        changes
+    }, workspaceId);
+}
 const MAX_WORKSPACE_PUSH_CHANGES_PER_REQUEST = 64;
 const MAX_WORKSPACE_PUSH_BYTES_PER_REQUEST = 4 * 1024 * 1024;
 const MAX_WORKSPACE_PUSH_SINGLE_CHANGE_BYTES = 45 * 1024 * 1024;
@@ -428,6 +433,7 @@ export async function runWorkspacePushSyncService(input) {
                 currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
                 currentWorkstreamIds: input.payload.currentWorkstreamIds,
                 currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+                currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
                 currentAiProfileIds: input.payload.currentAiProfileIds,
                 currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
                 currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -491,6 +497,7 @@ export async function runWorkspacePushSyncService(input) {
             currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
             currentWorkstreamIds: input.payload.currentWorkstreamIds,
             currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+            currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
             currentAiProfileIds: input.payload.currentAiProfileIds,
             currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
             currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -583,6 +590,7 @@ export async function runWorkspacePushSyncService(input) {
             currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
             currentWorkstreamIds: input.payload.currentWorkstreamIds,
             currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+            currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
             currentAiProfileIds: input.payload.currentAiProfileIds,
             currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
             currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -670,8 +678,18 @@ export async function runWorkspacePushSyncService(input) {
         && acknowledgedNonApplyingBatchOperationIdentities.size !== requestedAcknowledgements.length) {
         throw new Error('Persisted V2 push batch acknowledgement state does not match the frozen push plan.');
     }
+    const requestedSettledBatchOperationIdentities = input.settledBatchOperationIdentities || [];
+    if ((requestedSettledBatchOperationIdentities.length > 0
+        && !input.onAcceptedBatchSettled)
+        || new Set(requestedSettledBatchOperationIdentities).size
+            !== requestedSettledBatchOperationIdentities.length
+        || requestedSettledBatchOperationIdentities.some((identity) => !batchOperationIdentities.includes(identity))) {
+        throw new Error('Persisted V2 push batch settlement state does not match the frozen push plan.');
+    }
+    const settledBatchOperationIdentities = new Set(requestedSettledBatchOperationIdentities);
     let completedBatchCount = 0;
     let completedChangeCount = 0;
+    let firstPushFailure = null;
     const pushTransferReceipts = [];
     const abandonRetainedPushReceipts = async (errorCode) => {
         if (pushTransferReceipts.length === 0)
@@ -689,7 +707,8 @@ export async function runWorkspacePushSyncService(input) {
             const safeBatchChanges = batch.map((entry) => entry.safe);
             const expectedTaskEchoIds = workspaceSyncEngineExpectedTaskEchoIds(plainBatchChanges);
             const idempotencyKey = batchOperationIdentities[batchIndex];
-            if (acknowledgedNonApplyingBatchOperationIdentities.has(idempotencyKey)) {
+            if (settledBatchOperationIdentities.has(idempotencyKey)
+                || acknowledgedNonApplyingBatchOperationIdentities.has(idempotencyKey)) {
                 completedBatchCount += 1;
                 completedChangeCount += plainBatchChanges.length;
                 continue;
@@ -732,7 +751,12 @@ export async function runWorkspacePushSyncService(input) {
                 const data = asObjectRecord(pushResult.data);
                 const failedOperations = Array.from(new Set(plainBatchChanges.map((change) => change.op)));
                 const failedContentChanges = plainBatchChanges.filter(isWorkspacePushContentChange).length;
-                return {
+                const failureDomain = failedContentChanges === plainBatchChanges.length
+                    ? 'content'
+                    : failedContentChanges === 0
+                        ? 'metadata'
+                        : 'mixed';
+                const failureResult = {
                     success: false,
                     status: pushResult.status,
                     error: typeof data.error === 'string' ? data.error : undefined,
@@ -744,11 +768,7 @@ export async function runWorkspacePushSyncService(input) {
                         failedBatchIndex: batchIndex,
                         failedChangeCount: plainBatchChanges.length,
                         failedOperations,
-                        failureDomain: failedContentChanges === plainBatchChanges.length
-                            ? 'content'
-                            : failedContentChanges === 0
-                                ? 'metadata'
-                                : 'mixed',
+                        failureDomain,
                     },
                     retryAfterMs: pushResult.retryAfterMs,
                     transient: pushInProgress || isTransientWorkspaceSyncStatus(pushResult.status),
@@ -765,6 +785,7 @@ export async function runWorkspacePushSyncService(input) {
                     currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
                     currentWorkstreamIds: input.payload.currentWorkstreamIds,
                     currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+                    currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
                     currentAiProfileIds: input.payload.currentAiProfileIds,
                     currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
                     currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -793,8 +814,18 @@ export async function runWorkspacePushSyncService(input) {
                     pushedWatermarks: new Map(),
                     pushedTaskChangeKeys: new Map(),
                     emittedEventIds: [],
-                    appliedTaskUpserts: []
+                    appliedTaskUpserts: [],
                 };
+                firstPushFailure ||= failureResult;
+                // Only content is isolated from later durable projections.
+                // Ownership, auth, and metadata failures can invalidate phase
+                // dependencies, so they still stop the attempt immediately.
+                if (failureDomain !== 'content')
+                    return failureResult;
+                // Later phases contain independent relationships, events, and
+                // comments. Let them settle and checkpoint their non-applying
+                // receipts even though this attempt reports the content failure.
+                continue;
             }
             const pushData = asObjectRecord(pushResult.data);
             if (Array.isArray(pushData.emittedEventIds)) {
@@ -806,7 +837,29 @@ export async function runWorkspacePushSyncService(input) {
             }
             const normalizedTaskUpserts = parseWorkspaceSyncEngineAppliedTaskUpserts(pushData, expectedTaskEchoIds);
             appliedTaskUpserts.push(...normalizedTaskUpserts);
-            if (pushResult.transferReceipt && normalizedTaskUpserts.length === 0) {
+            if (input.onAcceptedBatchSettled) {
+                if (!pushResult.transferReceipt) {
+                    throw new Error('Accepted V2 push batch is missing its atomic settlement receipt.');
+                }
+                await input.onAcceptedBatchSettled({
+                    operationIdentity: idempotencyKey,
+                    settlementIdentityFingerprint: await computeCanonicalWorkspaceSyncSha256(createWorkspaceSyncEngineV2SettlementIdentityProjection({
+                        operationIdentity: idempotencyKey,
+                        changes: plainBatchChanges,
+                        appliedTaskUpserts: normalizedTaskUpserts,
+                        excludedProjections: effectiveV2ExcludedProjections,
+                    })),
+                    appliedTaskUpserts: normalizedTaskUpserts,
+                    transferReceipt: pushResult.transferReceipt,
+                    pushBoundary,
+                    excludedProjections: effectiveV2ExcludedProjections,
+                });
+                const receiptIndex = pushTransferReceipts.indexOf(pushResult.transferReceipt);
+                if (receiptIndex >= 0)
+                    pushTransferReceipts.splice(receiptIndex, 1);
+                settledBatchOperationIdentities.add(idempotencyKey);
+            }
+            else if (pushResult.transferReceipt && normalizedTaskUpserts.length === 0) {
                 await remoteServices.acknowledgeNonApplyingTransferReceipts({
                     workspaceId: input.workspaceId,
                     receipts: [pushResult.transferReceipt],
@@ -828,6 +881,17 @@ export async function runWorkspacePushSyncService(input) {
         await abandonRetainedPushReceipts('WORKSPACE_SYNC_V2_PUSH_ATTEMPT_FAILED');
         throw error;
     }
+    if (firstPushFailure) {
+        return {
+            ...firstPushFailure,
+            batchProgress: {
+                ...firstPushFailure.batchProgress,
+                completedBatches: completedBatchCount,
+                completedChanges: completedChangeCount,
+            },
+            requestMs,
+        };
+    }
     return {
         success: true,
         syncedAt: new Date().toISOString(),
@@ -855,6 +919,7 @@ export async function runWorkspacePushSyncService(input) {
         currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
         currentWorkstreamIds: input.payload.currentWorkstreamIds,
         currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+        currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
         currentAiProfileIds: input.payload.currentAiProfileIds,
         currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
         currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),

package/dist/sync/taskforceAgentSyncAuthorization.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceSyncTaskforceAgentSnapshot } from './workspaceSyncModel.js';
+type SyncAuthorizationError = Error & {
+    code?: string;
+    statusCode?: number;
+    details?: Record<string, unknown>;
+};
+export declare function assertTaskforceAgentSyncPushAccess(input: {
+    agents: Iterable<WorkspaceSyncTaskforceAgentSnapshot>;
+    actorUserId: string | null;
+    hasUserFeatureGrant: (userId: string, featureKey: unknown) => boolean;
+    createSyncRouteError: (message: string, details: Record<string, unknown>, options?: {
+        code?: string;
+        statusCode?: number;
+    }) => SyncAuthorizationError;
+}): void;
+export {};

package/dist/sync/taskforceAgentSyncAuthorization.js

@@ -0,0 +1,20 @@
+import { getTaskforceAgentModel } from '../shared/taskforceAgentModels.js';
+import { INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY } from '../shared/userFeatureGrants.js';
+export function assertTaskforceAgentSyncPushAccess(input) {
+    const actorUserId = String(input.actorUserId || '').trim();
+    for (const agent of input.agents) {
+        if (agent.deletedAt)
+            continue;
+        const modelKey = String(agent.definition?.model?.modelKey || agent.modelKey || '').trim();
+        if (getTaskforceAgentModel(modelKey)?.source !== 'subscription_dev')
+            continue;
+        if (actorUserId && input.hasUserFeatureGrant(actorUserId, INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY))
+            continue;
+        throw input.createSyncRouteError(`Subscription-backed Taskforce Agent ${agent.id} requires an internal user grant.`, {
+            source: 'apply.taskforceAgentUpsert',
+            agentId: agent.id,
+            actorUserId: actorUserId || null,
+            featureKey: INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY,
+        }, { code: 'SUBSCRIPTION_MODEL_ACCESS_REQUIRED', statusCode: 403 });
+    }
+}

package/dist/sync/v3/combinedFeedCapability.js

@@ -4,6 +4,7 @@ import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR } from './workspaceSyncV3Nes
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowWireContract.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR } from './workspaceSyncV3PlanningOrderWireContract.js';
 import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR } from './workspaceSyncV3TaskCoverWireContract.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowTaskCoverWireContract.js';
 export { WORKSPACE_SYNC_V3_COMBINED_CAPABILITY_VERSION } from './workspaceSyncV3CombinedWireContract.js';
 export function resolveRequestedCombinedFeedCoverage(env = process.env) {
     const requestedVersion = String(env.TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION || '').trim();
@@ -22,6 +23,9 @@ export function resolveRequestedCombinedFeedCoverage(env = process.env) {
     if (requestedVersion === String(WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR.coverageVersion)) {
         return WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR;
     }
+    if (requestedVersion === String(WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR.coverageVersion)) {
+        return WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR;
+    }
     throw new Error(`Unsupported TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION: ${requestedVersion}.`);
 }
 export function resolveCombinedFeedCapability(input) {

package/dist/sync/v3/durableInitiativeMutationRouter.js

@@ -7,6 +7,7 @@ import { enqueueLocalInitiativeMutation, } from './localInitiativeOutboxService.
 import { isWorkspaceSyncV3PlanningActivationEnabled } from './planningActivation.js';
 import { serializeEntityActivityForSync } from './taskActivityJournal.js';
 import { WorkspaceSyncDurabilityStore, WorkspaceSyncIdempotencyConflictError } from './syncDurabilityStore.js';
+import { readDurableOperationReplay } from './durableOperationReplay.js';
 import { buildInitiativeActivityEventId } from './initiativeActivityIdentity.js';
 const OPERATION_LEASE_MS = 30_000;
 export class DurableInitiativeMutationRouterDisabledError extends Error {
@@ -85,6 +86,9 @@ export function createDurableInitiativeMutationRouter(input) {
                 if (persistedOutbox.domain !== 'initiative' || persistedOutbox.entityId !== initiativeId) {
                     throw new WorkspaceSyncIdempotencyConflictError();
                 }
+                store.assertOutboxOperationIdentity(persistedOutbox, {
+                    domain: 'initiative', entityId: initiativeId, mutationKind: persistedOutbox.mutationKind,
+                });
                 return {
                     revisions: {
                         entityRevision: persistedOutbox.baseEntityRevision,
@@ -99,18 +103,22 @@ export function createDurableInitiativeMutationRouter(input) {
             if (operationState?.status === 'committed') {
                 if (!operationState.responseJson)
                     throw new Error('Committed operation is missing its response.');
-                const response = JSON.parse(operationState.responseJson);
-                if (response.authoritative.entityId !== initiativeId) {
-                    throw new WorkspaceSyncIdempotencyConflictError();
-                }
-                const lifecycleMutation = response.authoritative.mutationKind === 'archive'
-                    || response.authoritative.mutationKind === 'unarchive';
+                const parsed = JSON.parse(operationState.responseJson);
+                const lifecycleMutation = parsed.authoritative.mutationKind === 'archive'
+                    || parsed.authoritative.mutationKind === 'unarchive';
+                const replay = readDurableOperationReplay({
+                    responseJson: operationState.responseJson,
+                    operationId,
+                    domain: 'initiative',
+                    entityId: initiativeId,
+                    mutationKind: parsed.authoritative.mutationKind,
+                    revisionMode: lifecycleMutation ? 'both' : 'metadata',
+                });
+                const response = replay.response;
                 return {
                     revisions: {
-                        entityRevision: String(BigInt(response.authoritative.entityRevision) - 1n),
-                        lifecycleRevision: lifecycleMutation
-                            ? String(BigInt(response.authoritative.lifecycleRevision) - 1n)
-                            : response.authoritative.lifecycleRevision,
+                        entityRevision: replay.baseEntityRevision,
+                        lifecycleRevision: replay.baseLifecycleRevision,
                     },
                     persistedOutbox: null,
                     committedResponse: response,

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

@@ -15,6 +15,20 @@ export declare class DurableOperationReplayIdentityConflictError extends Error {
     readonly code = "DURABLE_OPERATION_REPLAY_IDENTITY_CONFLICT";
     constructor(message?: string);
 }
+export interface DurableOperationIdentityRecord {
+    operationId: string;
+    domain: string;
+    entityId: string;
+    mutationKind: string;
+    payloadFingerprint: string;
+}
+/**
+ * Canonical identity comparison for durable mutation records. Storage lanes may
+ * retain different reservation metadata, but an accepted operation can have
+ * only one exact domain/entity/mutation/payload meaning.
+ */
+export declare function assertDurableOperationIdentity(actual: Readonly<DurableOperationIdentityRecord>, expected: Readonly<DurableOperationIdentityRecord>): void;
+export declare function assertDurableOperationFingerprint(actual: string, expected: string): void;
 export interface DurableOperationReplayResult<Payload = unknown> {
     response: Readonly<Record<string, unknown>>;
     authoritative: DurableOperationAuthoritativeEntry<Payload>;

package/dist/sync/v3/durableOperationReplay.js

@@ -12,6 +12,24 @@ export class DurableOperationReplayIdentityConflictError extends Error {
         this.name = 'DurableOperationReplayIdentityConflictError';
     }
 }
+/**
+ * Canonical identity comparison for durable mutation records. Storage lanes may
+ * retain different reservation metadata, but an accepted operation can have
+ * only one exact domain/entity/mutation/payload meaning.
+ */
+export function assertDurableOperationIdentity(actual, expected) {
+    if (actual.operationId !== expected.operationId
+        || actual.domain !== expected.domain
+        || actual.entityId !== expected.entityId
+        || actual.mutationKind !== expected.mutationKind
+        || actual.payloadFingerprint !== expected.payloadFingerprint) {
+        throw new DurableOperationReplayIdentityConflictError();
+    }
+}
+export function assertDurableOperationFingerprint(actual, expected) {
+    if (!actual || actual !== expected)
+        throw new DurableOperationReplayIdentityConflictError();
+}
 const DEFAULT_MAX_AUTHORITATIVE_ENTRIES = 1_024;
 const POSITIVE_REVISION = /^[1-9]\d*$/;
 const NON_NEGATIVE_REVISION = /^(0|[1-9]\d*)$/;

package/dist/sync/v3/durableTaskAttachmentLinksMutationRouter.js

@@ -150,6 +150,9 @@ export function createDurableTaskAttachmentLinksMutationRouter(input) {
                         || String(payload.cardCoverAssetId || '') !== String(cardCoverAssetId || '')) {
                         throw new DurableTaskAttachmentLinksMutationError('Operation identity is assigned to different task attachment links.', 'TASK_ATTACHMENT_LINKS_IDENTITY_CONFLICT', 409);
                     }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'task-attachment-links', entityId: taskId, mutationKind: 'replace',
+                    });
                     const task = input.core.getTask(taskId, workspaceId);
                     if (!task)
                         throw new DurableTaskAttachmentLinksMutationError('Task not found.', 'TASK_NOT_FOUND', 404);

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

@@ -1,7 +1,7 @@
 import type { ChecklistItem, TaskItem } from '../../core/Taskforce.js';
 import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
 import { type LocalTaskChecklistOutboxCore } from './localTaskChecklistOutboxService.js';
-import { type DurableTaskChecklistServiceCore } from './taskChecklistMutationService.js';
+import { type DurableTaskChecklistServiceCore, type TaskChecklistItemUpdateIntent } from './taskChecklistMutationService.js';
 export declare function resolveTaskChecklistMutationCapability(input: {
     runtimeMode: 'local' | 'cloud';
     surface: 'http' | 'mcp';
@@ -40,6 +40,7 @@ export declare function createDurableTaskChecklistMutationRouter(input: {
         taskId: string;
         items: readonly Partial<ChecklistItem>[];
         expectedDetailRevision?: string;
+        itemUpdateIntent?: TaskChecklistItemUpdateIntent;
     }): {
         state: "pending" | "committed";
         route: "local-outbox" | "cloud-acceptance";

package/dist/sync/v3/durableTaskChecklistMutationRouter.js

@@ -1,7 +1,7 @@
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { LocalSyncIdentityStore } from './localSyncIdentityStore.js';
 import { enqueueLocalTaskChecklistMutation, } from './localTaskChecklistOutboxService.js';
-import { DurableTaskChecklistMutationError, runDurableTaskChecklistReplace, } from './taskChecklistMutationService.js';
+import { DurableTaskChecklistMutationError, runDurableTaskChecklistReplace, validateTaskChecklistItemUpdateIntent, } from './taskChecklistMutationService.js';
 import { WorkspaceSyncDurabilityStore, WorkspaceSyncEntityBusyError } from './syncDurabilityStore.js';
 import { serializeWorkspaceSyncV3TaskChecklistPayload } from './workspaceSyncV3NestedTaskCodecs.js';
 const OPERATION_LEASE_MS = 30_000;
@@ -82,6 +82,18 @@ export function createDurableTaskChecklistMutationRouter(input) {
             catch (error) {
                 throw new DurableTaskChecklistMutationError(error instanceof Error ? error.message : 'Task checklist is invalid.', 'TASK_CHECKLIST_INVALID', 400);
             }
+            const itemUpdateIntent = args.itemUpdateIntent
+                ? validateTaskChecklistItemUpdateIntent(args.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 acceptedAt = now();
             const acceptedAtIso = acceptedAt.toISOString();
             const operationId = operationIdRequired(input.operationId);
@@ -109,25 +121,43 @@ export function createDurableTaskChecklistMutationRouter(input) {
                     catch {
                         throw new DurableTaskChecklistMutationError('Captured task checklist payload is invalid.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                     }
-                    if (canonicalWorkspaceSyncJson(frozen) !== canonicalWorkspaceSyncJson(items)) {
+                    const capturedIntent = payload.itemUpdateIntent
+                        ? validateTaskChecklistItemUpdateIntent(payload.itemUpdateIntent)
+                        : undefined;
+                    const requestedIntent = itemUpdateIntent;
+                    if (capturedIntent || requestedIntent
+                        ? canonicalWorkspaceSyncJson(capturedIntent) !== canonicalWorkspaceSyncJson(requestedIntent)
+                        : canonicalWorkspaceSyncJson(frozen) !== canonicalWorkspaceSyncJson(items)) {
                         throw new DurableTaskChecklistMutationError('Operation identity is assigned to a different task checklist.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                     }
+                    if ((payload.expectedDetailRevision || undefined) !== (args.expectedDetailRevision || undefined)) {
+                        throw new DurableTaskChecklistMutationError('Operation identity is assigned to a different task checklist precondition.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
+                    }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'task-checklist', entityId: taskId, mutationKind: 'replace',
+                    });
                     const task = input.core.getTask(taskId, workspaceId);
                     if (!task)
                         throw new DurableTaskChecklistMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
                     const installed = serializeWorkspaceSyncV3TaskChecklistPayload({
                         taskId, items: task.checklistItems || [],
                     }).items;
-                    if (canonicalWorkspaceSyncJson(installed) !== canonicalWorkspaceSyncJson(frozen)) {
+                    if (!capturedIntent
+                        && canonicalWorkspaceSyncJson(installed) !== canonicalWorkspaceSyncJson(frozen)) {
                         throw new DurableTaskChecklistMutationError('Captured task checklist does not match local state.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                     }
-                    return { state: 'pending', route: 'local-outbox', operationId, task };
+                    return {
+                        state: 'pending', route: 'local-outbox', operationId,
+                        task: capturedIntent ? { ...task, checklistItems: frozen } : task,
+                    };
                 }
                 let result;
                 try {
                     result = enqueueLocalTaskChecklistMutation({
                         store, core: input.core, identity, taskId, items, now: acceptedAtIso,
                         actorRef, onPostCommitError: input.onPostCommitError,
+                        expectedDetailRevision: args.expectedDetailRevision,
+                        itemUpdateIntent,
                         requireV3CombinedOwnership: persistedOwnershipChecked,
                     });
                 }
@@ -142,6 +172,7 @@ export function createDurableTaskChecklistMutationRouter(input) {
                 return { state: 'pending', route: 'local-outbox', operationId, task };
             }
             const committed = store.readCommittedOperationResponse(identity);
+            let coordinates;
             if (committed) {
                 let response;
                 try {
@@ -150,27 +181,33 @@ export function createDurableTaskChecklistMutationRouter(input) {
                 catch {
                     throw new DurableTaskChecklistMutationError('Committed task checklist response is invalid.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                 }
+                const projection = response.authoritative?.checklist;
+                const acceptedRevision = String(projection?.entityRevision || '');
+                const lifecycleRevision = String(projection?.lifecycleRevision || '');
                 if (response.workspaceId !== workspaceId || response.clientId !== clientId
                     || response.operationId !== operationId || response.authoritative?.root?.entityId !== taskId
-                    || response.authoritative?.checklist?.entityId !== taskId
-                    || canonicalWorkspaceSyncJson(response.authoritative.checklist.payload?.items || [])
-                        !== canonicalWorkspaceSyncJson(items)) {
+                    || projection?.entityId !== taskId
+                    || !/^[1-9]\d*$/.test(acceptedRevision)
+                    || !/^(0|[1-9]\d*)$/.test(lifecycleRevision)) {
                     throw new DurableTaskChecklistMutationError('Operation identity is assigned to a different task checklist.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                 }
-                const task = input.core.getTask(taskId, workspaceId);
-                if (!task)
-                    throw new DurableTaskChecklistMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
-                return { state: 'committed', route: 'cloud-acceptance', operationId, task };
+                coordinates = {
+                    entityRevision: String(BigInt(acceptedRevision) - 1n),
+                    lifecycleRevision,
+                };
+            }
+            else {
+                coordinates = store.readEntityRevisionCoordinates({
+                    tenantId, workspaceId, domain: 'task-checklist', entityId: taskId,
+                });
             }
-            const coordinates = store.readEntityRevisionCoordinates({
-                tenantId, workspaceId, domain: 'task-checklist', entityId: taskId,
-            });
             const result = runDurableTaskChecklistReplace({
                 store, core: input.core, tenantId, workspaceId, clientId, operationId, taskId, items,
                 baseEntityRevision: coordinates.entityRevision, baseLifecycleRevision: coordinates.lifecycleRevision,
                 now: acceptedAtIso, leaseExpiresAt: new Date(acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                 actorRef, onPostCommitError: input.onPostCommitError,
                 expectedDetailRevision: args.expectedDetailRevision,
+                itemUpdateIntent,
                 assertPrecondition: args.expectedDetailRevision
                     ? () => input.core.assertTaskDetailRevisionForUpdate(taskId, args.expectedDetailRevision, workspaceId)
                     : undefined,
@@ -180,7 +217,13 @@ export function createDurableTaskChecklistMutationRouter(input) {
             const task = input.core.getTask(taskId, workspaceId);
             if (!task)
                 throw new DurableTaskChecklistMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
-            return { state: 'committed', route: 'cloud-acceptance', operationId, task };
+            return {
+                state: 'committed', route: 'cloud-acceptance', operationId,
+                task: {
+                    ...task,
+                    checklistItems: result.response.authoritative.checklist.payload.items,
+                },
+            };
         },
     };
 }

package/dist/sync/v3/durableTaskCommentMutationRouter.js

@@ -113,6 +113,9 @@ export function createDurableTaskCommentMutationRouter(input) {
                     if (!sameCommentRetryIntent(existingPayload.comment, canonical)) {
                         throw new DurableTaskCommentMutationError('Operation identity is assigned to a different task comment.', 'TASK_COMMENT_IDENTITY_CONFLICT', 409);
                     }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'task-comments', entityId: taskId, mutationKind: 'append',
+                    });
                     const frozenComment = serializeWorkspaceSyncV3TaskCommentsPayload({
                         taskId, comments: [existingPayload.comment],
                     }).comments[0];

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

@@ -38,5 +38,5 @@ export declare function createDurableTaskHttpRootMutationRouter(input: {
     restore(deletedRecordIdInput: string, restoreDestination?: TaskRestoreDestination): TaskItem;
     delete(taskIdInput: string): DeletedTaskRecord;
 };
-type TaskforceCoreForHttpRootMutation = Pick<import('../../core/Taskforce.js').TaskforceCore, 'getDatabaseAdapter' | 'getTask' | 'getTaskDetailRevision' | 'assertTaskDetailRevisionForUpdate' | 'listAssignableActors' | 'getDeletedTask' | 'updateTask' | 'hasTaskDeletionMarkerForSync' | 'createTask' | 'listTaskAttachmentLinksForDurableSync' | 'resolveTaskAttachmentLinksForDurableSync' | 'normalizeTaskAttachmentDescriptorsForDurableSync' | 'notifyDurableTaskCreateCommitted' | 'notifyDurableTaskBatchCommitted' | 'notifyDurableTaskMetadataCommitted' | 'notifyDurableTaskLifecycleCommitted' | 'notifyDurableTaskDeleteCommitted' | 'getTaskEventForSync' | 'getEntityEventForSync' | 'lockTaskLifecycleMutationDomain' | 'archiveTask' | 'unarchiveTask' | 'restoreDeletedTask' | 'addTaskStatusEventsForDurableSync' | 'lockTaskRelationshipMutationDomain' | 'listTaskRelationships' | 'getTaskRelationshipForSync' | 'deleteTaskForSync'>;
+type TaskforceCoreForHttpRootMutation = Pick<import('../../core/Taskforce.js').TaskforceCore, 'getDatabaseAdapter' | 'getTask' | 'getTaskDetailRevision' | 'assertTaskDetailRevisionForUpdate' | 'listAssignableActors' | 'getDeletedTask' | 'updateTask' | 'hasTaskDeletionMarkerForSync' | 'createTask' | 'listTaskAttachmentLinksForDurableSync' | 'resolveTaskAttachmentLinksForDurableSync' | 'normalizeTaskAttachmentDescriptorsForDurableSync' | 'notifyDurableTaskCreateCommitted' | 'notifyDurableTaskBatchCommitted' | 'notifyDurableTaskMetadataCommitted' | 'notifyDurableTaskLifecycleCommitted' | 'notifyDurableTaskDeleteCommitted' | 'getTaskEventForSync' | 'getEntityEventForSync' | 'lockTaskLifecycleMutationDomain' | 'archiveTask' | 'unarchiveTask' | 'restoreDeletedTask' | 'addTaskStatusEventsForDurableSync' | 'addTaskCommentEventForDurableSync' | 'lockTaskRelationshipMutationDomain' | 'listTaskRelationships' | 'getTaskRelationshipForSync' | 'deleteTaskForSync'>;
 export {};

package/dist/sync/v3/durableTaskHttpRootMutationRouter.js

@@ -2,6 +2,7 @@ import { selectDurableTaskMetadataPatch } from '../../core/TaskDurableSyncMutati
 import { prepareTaskDeleteForDurableSync } from '../../core/TaskDurableDeleteMutationService.js';
 import { selectTaskCreateActivationInput } from './taskCreateActivation.js';
 import { resolveTaskAttachmentLinksMutationCapability } from './durableTaskAttachmentLinksMutationRouter.js';
+import { areWorkflowRuntimeMutationsFenced, resolveWorkflowRuntimeDurableTransportCapability, } from './durableWorkflowRuntimeMutationRouter.js';
 import { runDurableTaskCreate } from './taskCreateMutationService.js';
 import { runDurableTaskDelete } from './taskDeleteMutationService.js';
 import { runDurableTaskLifecycleMutation } from './taskLifecycleMutationService.js';
@@ -59,6 +60,13 @@ export function createDurableTaskHttpRootMutationRouter(input) {
         surface: 'http',
         env: input.env,
     });
+    const workflowRuntimeJournalEnabled = resolveWorkflowRuntimeDurableTransportCapability({
+        runtimeMode: input.runtimeMode,
+        surface: 'http',
+        env: input.env,
+    });
+    const rejectWorkflowRuntimeActivation = workflowRuntimeJournalEnabled
+        && areWorkflowRuntimeMutationsFenced(input.env);
     const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
     const now = input.now || (() => new Date());
     const notificationMethods = new Set([
@@ -237,6 +245,8 @@ export function createDurableTaskHttpRootMutationRouter(input) {
                     now: operation.acceptedAtIso,
                     leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                     actorRef: input.actorRef,
+                    includeWorkflowRuntimeJournal: workflowRuntimeJournalEnabled,
+                    rejectWorkflowRuntimeActivation,
                     expectedDetailRevision,
                     assertPrecondition: detailRevisionPrecondition(taskId, expectedDetailRevision),
                     onPostCommitError: input.onPostCommitError,

package/dist/sync/v3/durableTaxonomyMutationRouter.js

@@ -185,6 +185,11 @@ export function createDurableTaxonomyMutationRouter(input) {
             if (!sameTaxonomyState(storedPayload.state, canonicalState) || !Array.isArray(storedPayload.taskPatches)) {
                 throw new WorkspaceSyncIdempotencyConflictError();
             }
+            store.assertOutboxOperationIdentity(existingOutbox, {
+                domain: WORKSPACE_SYNC_TAXONOMY_DOMAIN,
+                entityId: WORKSPACE_SYNC_TAXONOMY_ENTITY_ID,
+                mutationKind: WORKSPACE_SYNC_TAXONOMY_REPLACE_WITH_REMAPS,
+            });
             enqueueLocalTaxonomyCompositeReplacement({
                 store,
                 core: input.core,