@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/sync/engine/workspaceSyncEnginePushCompletion.js

@@ -1,3 +1,4 @@
+import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
 export const WORKSPACE_SYNC_ENGINE_V2_PUSH_BOUNDARY_VERSION = 1;
 export function createWorkspaceSyncEngineV2PushBoundary(batchOperationIdentities) {
     if (!Array.isArray(batchOperationIdentities)
@@ -85,3 +86,86 @@ export function parseWorkspaceSyncEngineAppliedTaskUpserts(value, expectedTaskId
     }
     return normalized;
 }
+function taskSettlementProjection(task, preserveReferenceNumber) {
+    const { updatedAt: _updatedAt, ...stableTask } = structuredClone(task);
+    if (!preserveReferenceNumber)
+        delete stableTask.referenceNumber;
+    return stableTask;
+}
+function taskSettlementOwnedProjection(input) {
+    // The cloud echo is authoritative for the complete task row, but this V2
+    // page may own only carrier fields. Validate exactly that remaining V2
+    // surface; V3-owned fields are checked by their own acknowledgement/feed.
+    const task = taskSettlementProjection(input.task, input.preserveReferenceNumber);
+    const rootOwnedByV3 = input.excludedProjections.has('task/root-v1');
+    const commentsOwnedByV3 = input.excludedProjections.has('task-comments/full-v1');
+    const checklistOwnedByV3 = input.excludedProjections.has('task-checklist/full-v1');
+    const attachmentLinksV1OwnedByV3 = input.excludedProjections
+        .has('task-attachment-links/full-v1');
+    const attachmentLinksV2OwnedByV3 = input.excludedProjections
+        .has('task-attachment-links/full-v2');
+    if (rootOwnedByV3) {
+        for (const key of Object.keys(task)) {
+            if (![
+                'id',
+                'comments',
+                'checklistItems',
+                'attachments',
+                'cardCoverAssetId',
+            ].includes(key)) {
+                delete task[key];
+            }
+        }
+    }
+    if (commentsOwnedByV3)
+        delete task.comments;
+    if (checklistOwnedByV3)
+        delete task.checklistItems;
+    if (attachmentLinksV1OwnedByV3 || attachmentLinksV2OwnedByV3) {
+        delete task.attachments;
+    }
+    if (attachmentLinksV2OwnedByV3)
+        delete task.cardCoverAssetId;
+    return {
+        ...(rootOwnedByV3 ? {} : { archived: input.archived }),
+        task,
+    };
+}
+export function createWorkspaceSyncEngineV2SettlementIdentityProjection(input) {
+    const operationIdentity = String(input.operationIdentity || '').trim();
+    if (!operationIdentity || operationIdentity !== input.operationIdentity) {
+        throw new TypeError('The V2 push settlement operation identity is invalid.');
+    }
+    const expectedTaskUpserts = input.changes.filter((change) => change.op === 'upsert');
+    if (expectedTaskUpserts.length !== input.appliedTaskUpserts.length) {
+        throw new TypeError('The V2 push authoritative settlement projection is incomplete.');
+    }
+    const expectedProjection = expectedTaskUpserts.map((change) => ({
+        archived: change.archived,
+        task: taskSettlementProjection(change.task, change.task.referenceNumber !== undefined && change.task.referenceNumber !== null),
+    }));
+    const excludedProjections = new Set(input.excludedProjections || []);
+    const expectedOwnedProjection = expectedTaskUpserts.map((change) => (taskSettlementOwnedProjection({
+        archived: change.archived,
+        task: change.task,
+        preserveReferenceNumber: change.task.referenceNumber !== undefined
+            && change.task.referenceNumber !== null,
+        excludedProjections,
+    })));
+    const authoritativeOwnedProjection = input.appliedTaskUpserts.map((entry, index) => (taskSettlementOwnedProjection({
+        archived: entry.archived,
+        task: entry.task,
+        preserveReferenceNumber: expectedTaskUpserts[index]?.task.referenceNumber !== undefined
+            && expectedTaskUpserts[index]?.task.referenceNumber !== null,
+        excludedProjections,
+    })));
+    if (canonicalWorkspaceSyncJson(authoritativeOwnedProjection)
+        !== canonicalWorkspaceSyncJson(expectedOwnedProjection)) {
+        throw new TypeError('The V2 push authoritative settlement does not match the canonical request state.');
+    }
+    return {
+        version: 1,
+        operationIdentity,
+        taskUpserts: expectedProjection,
+    };
+}

package/dist/sync/engine/workspaceSyncEngineRecovery.js

@@ -10,6 +10,7 @@ function resetWorkspaceSyncStatePushBaselines(runtime) {
     runtime.lastPushedInitiativeWatermarks.current = new Map();
     runtime.lastPushedWorkstreamIds.current = new Set();
     runtime.lastPushedWorkstreamWatermarks.current = new Map();
+    runtime.lastPushedPlanningIdentityWatermarks.current = new Map();
     runtime.lastPushedAiProfileIds.current = new Set();
     runtime.lastPushedAiProfileWatermarks.current = new Map();
     runtime.lastPushedAiProfileChangeKeys.current = new Map();

package/dist/sync/engine/workspaceSyncEngineRemoteServices.d.ts

@@ -37,6 +37,12 @@ export type WorkspaceSyncEngineContentPullInput = Parameters<typeof pullWorkspac
      * commit against one exact prior boundary.
      */
     previousCursor: string | null;
+    /**
+     * Separates an independent content lookup from a V2 feed page. The
+     * identity becomes an apply boundary that settles the transfer
+     * without advancing or validating the runner's V2 cursor.
+     */
+    independentCompletionIdentity?: string;
 };
 type RemoteResult<Result> = Awaited<Result> & {
     transferReceipt?: WorkspaceSyncEngineRemoteTransferReceipt;
@@ -94,6 +100,11 @@ export interface WorkspaceSyncEngineRemoteServices {
         nextCursor: string | null;
         receipts: readonly WorkspaceSyncEngineRemoteTransferReceipt[];
     }): WorkspaceSyncEngineTransferCompletionGroup | undefined;
+    buildIndependentContentApplyCompletionGroup(input: {
+        workspaceId: string;
+        identity: string;
+        receipts: readonly WorkspaceSyncEngineRemoteTransferReceipt[];
+    }): WorkspaceSyncEngineTransferCompletionGroup | undefined;
     buildV2PushApplyCompletionGroup(input: {
         workspaceId: string;
         pushBoundary: WorkspaceSyncEngineV2PushBoundary;

package/dist/sync/engine/workspaceSyncEngineRemoteServices.js

@@ -6,7 +6,7 @@ export function createBrowserWorkspaceSyncEngineRemoteServices(resolveCloudAuthU
         provisionWorkspace: (input) => provisionWorkspace(resolveCloudAuthUrl, input),
         pushWorkspaceChanges: ({ ownership: _ownership, pushBoundary: _pushBoundary, ...input }) => (pushWorkspaceChanges(resolveCloudAuthUrl, input)),
         pullWorkspaceChanges: (input) => pullWorkspaceChanges(resolveCloudAuthUrl, input),
-        pullWorkspaceContent: ({ previousCursor: _previousCursor, ...input }) => (pullWorkspaceContent(resolveCloudAuthUrl, input)),
+        pullWorkspaceContent: ({ previousCursor: _previousCursor, independentCompletionIdentity: _independentCompletionIdentity, ...input }) => (pullWorkspaceContent(resolveCloudAuthUrl, input)),
         pullInitiativeFeed: (input) => pullWorkspaceSyncV3Feed(resolveCloudAuthUrl, input),
         pullInitiativeRepair: (input) => pullWorkspaceInitiativeRepair(resolveCloudAuthUrl, input),
         pullCombinedFeed: (input) => pullWorkspaceSyncV3CombinedFeed(resolveCloudAuthUrl, input),
@@ -15,6 +15,7 @@ export function createBrowserWorkspaceSyncEngineRemoteServices(resolveCloudAuthU
         abandonTransferReceipts: () => undefined,
         acknowledgeNonApplyingTransferReceipts: () => undefined,
         buildV2ApplyCompletionGroup: () => undefined,
+        buildIndependentContentApplyCompletionGroup: () => undefined,
         buildV2PushApplyCompletionGroup: () => undefined,
         buildV3ApplyCompletionGroup: () => undefined,
     };

package/dist/sync/engine/workspaceSyncEngineRuntime.d.ts

@@ -26,6 +26,7 @@ export interface WorkspaceSyncEngineRuntime {
     lastPushedInitiativeWatermarks: WorkspaceSyncMutableValue<Map<string, string>>;
     lastPushedWorkstreamIds: WorkspaceSyncMutableValue<Set<string>>;
     lastPushedWorkstreamWatermarks: WorkspaceSyncMutableValue<Map<string, string>>;
+    lastPushedPlanningIdentityWatermarks: WorkspaceSyncMutableValue<Map<string, string>>;
     lastPushedAiProfileIds: WorkspaceSyncMutableValue<Set<string>>;
     lastPushedAiProfileWatermarks: WorkspaceSyncMutableValue<Map<string, string>>;
     lastPushedAiProfileChangeKeys: WorkspaceSyncMutableValue<Map<string, string>>;

package/dist/sync/engine/workspaceSyncEngineRuntime.js

@@ -24,6 +24,7 @@ export function createWorkspaceSyncEngineRuntime() {
         lastPushedInitiativeWatermarks: mutable(new Map()),
         lastPushedWorkstreamIds: mutable(new Set()),
         lastPushedWorkstreamWatermarks: mutable(new Map()),
+        lastPushedPlanningIdentityWatermarks: mutable(new Map()),
         lastPushedAiProfileIds: mutable(new Set()),
         lastPushedAiProfileWatermarks: mutable(new Map()),
         lastPushedAiProfileChangeKeys: mutable(new Map()),

package/dist/sync/engine/workspaceSyncEngineServerRemoteServices.js

@@ -40,6 +40,18 @@ function v3Boundary(input) {
         ...(input.coverage ? { coverage: { ...input.coverage } } : {}),
     };
 }
+function independentContentBoundary(identity) {
+    const normalizedIdentity = String(identity || '').trim();
+    if (!normalizedIdentity) {
+        throw new TypeError('Independent content transfer identity is required.');
+    }
+    return {
+        version: 1,
+        projection: 'independent-content',
+        cursor: null,
+        identity: normalizedIdentity,
+    };
+}
 function decodeGatewayResult(result, nowMs) {
     const rawText = new TextDecoder().decode(result.body);
     let data = {};
@@ -96,12 +108,15 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
             throw new TypeError('The server sync operation workspace does not match its runner.');
         }
     };
-    const abandon = (permitId, errorCode) => (options.permitStore.abandonPermit({
+    const abandon = (permitId, errorCode, readResponseUnavailableBeforeApply = false) => (options.permitStore.abandonPermit({
         permitId,
         workspaceId: options.workspaceId,
         coordinatorGeneration: options.coordinatorGeneration,
         serverInstanceId: options.serverInstanceId,
         errorCode,
+        ...(readResponseUnavailableBeforeApply
+            ? { readResponseUnavailableBeforeApply: true }
+            : {}),
     }));
     const execute = async (input) => {
         assertWorkspace(input.operation.workspaceId);
@@ -131,7 +146,7 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
             });
         }
         catch (error) {
-            abandon(permit.permitId, 'SYNC_COORDINATOR_GATEWAY_REQUEST_FAILED');
+            abandon(permit.permitId, 'SYNC_COORDINATOR_GATEWAY_REQUEST_FAILED', operationClass === 'pull' || operationClass === 'repair');
             throw error;
         }
         const decoded = decodeGatewayResult(gatewayResult, issuedAt.getTime());
@@ -171,6 +186,12 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
             abandon(permit.permitId, 'SYNC_COORDINATOR_APPLYING_REJECTED');
             return result;
         }
+        if (!result.ok
+            && completedPermit.upstreamDisposition === 'unknown'
+            && (operationClass === 'pull' || operationClass === 'repair')) {
+            abandon(permit.permitId, 'SYNC_COORDINATOR_GATEWAY_REQUEST_FAILED', true);
+            return result;
+        }
         if (!input.previousBoundary) {
             abandon(permit.permitId, 'SYNC_COORDINATOR_APPLY_BOUNDARY_MISSING');
             throw new Error('A server applying request did not declare its prior boundary.');
@@ -319,10 +340,12 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
             });
         },
         pullWorkspaceContent: (input) => {
-            const { previousCursor, ...request } = input;
+            const { previousCursor, independentCompletionIdentity, ...request } = input;
             return execute({
                 operation: { type: 'content-pull', ...request },
-                previousBoundary: v2Boundary(previousCursor),
+                previousBoundary: independentCompletionIdentity
+                    ? independentContentBoundary(independentCompletionIdentity)
+                    : v2Boundary(previousCursor),
                 applying: true,
             });
         },
@@ -433,6 +456,10 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
             }
         },
         buildV2ApplyCompletionGroup: ({ workspaceId, previousCursor, nextCursor, receipts, }) => completionGroup(workspaceId, receipts, v2Boundary(previousCursor), v2Boundary(nextCursor)),
+        buildIndependentContentApplyCompletionGroup: ({ workspaceId, identity, receipts, }) => {
+            const boundary = independentContentBoundary(identity);
+            return completionGroup(workspaceId, receipts, boundary, boundary);
+        },
         buildV2PushApplyCompletionGroup: ({ workspaceId, pushBoundary, receipts, }) => completionGroup(workspaceId, receipts, parseWorkspaceSyncEngineV2PushBoundary(pushBoundary), parseWorkspaceSyncEngineV2PushBoundary(pushBoundary)),
         buildV3ApplyCompletionGroup: ({ workspaceId, apply, receipts }) => {
             const metadata = readReceipts(workspaceId, receipts);

package/dist/sync/engine/workspaceSyncEngineServerRunnerOperations.d.ts

@@ -2,7 +2,7 @@ import type { LocalWorkspaceSyncRunnerOperations } from '../coordinator/localWor
 import { type EnsureWorkspaceReadyResult } from '../syncService.js';
 import type { WorkspaceSyncV2ProjectionExclusion } from '../v3/workspaceSyncV2ProjectionExclusions.js';
 import type { WorkspaceSyncV3CombinedCoverageSelector } from '../v3/workspaceSyncV3CombinedWireContract.js';
-import type { WorkspaceSyncEngineLocalServices } from './workspaceSyncEngineLocalServices.js';
+import { type WorkspaceSyncEngineLocalServices } from './workspaceSyncEngineLocalServices.js';
 import type { WorkspaceSyncEngineRemoteServices } from './workspaceSyncEngineRemoteServices.js';
 import type { WorkspaceSyncEngineServerPushCandidateProvider } from './workspaceSyncEngineServerSnapshotReader.js';
 import type { WorkspaceSyncEngineServerCheckpointPort } from './workspaceSyncEngineServerApplyBoundary.js';
@@ -46,11 +46,13 @@ export interface WorkspaceSyncEngineServerAttachmentApplyPort {
         } | {
             success: false;
             error: string;
+            disposition?: 'retryable' | 'terminal-unavailable';
         }>;
     }): Promise<{
         attempted: number;
         resolved: number;
         remaining: number;
+        terminal: number;
         nextAttemptAt: string | null;
         lastError: string | null;
     }>;

package/dist/sync/engine/workspaceSyncEngineServerRunnerOperations.js

@@ -1,11 +1,12 @@
 import { createHash } from 'crypto';
-import { createLocalWorkspaceSyncPendingV2Push, decodeWorkspaceSyncPayload, fingerprintLocalWorkspaceSyncPreparedPlan, isLocalWorkspaceSyncPullFairnessDue, } from '../coordinator/localWorkspaceSyncRunnerState.js';
+import { createLocalWorkspaceSyncPendingV2Push, decodeWorkspaceSyncPayload, fingerprintLocalWorkspaceSyncPreparedPlan, isLocalWorkspaceSyncPullFairnessDue, upgradeLocalWorkspaceSyncPendingV2PushSettlement, } from '../coordinator/localWorkspaceSyncRunnerState.js';
 import { isTransientWorkspaceSyncStatus, runWorkspacePullSyncService, runWorkspacePushSyncService, } from '../syncService.js';
 import { hydrateWorkspaceSyncV3AttachmentAsset } from '../v3/workspaceSyncV3AttachmentAssetHydration.js';
 import { runWorkspaceSyncV3CombinedProjectionCycle } from '../v3/workspaceSyncV3CombinedFeedOrchestrator.js';
 import { runWorkspaceSyncV3InitiativeProjectionCycle } from '../v3/workspaceSyncV3FeedOrchestrator.js';
 import { normalizeWorkspaceSyncV2ProjectionExclusions } from '../v3/workspaceSyncV2ProjectionExclusions.js';
 import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
+import { authoritativeV2ApplyFailureMessage, } from './workspaceSyncEngineLocalServices.js';
 import { combinedAttachmentAssetHydrationId, createWorkspaceSyncV3TransferBindings, } from './workspaceSyncEngineTransfers.js';
 import { createWorkspaceSyncTransferEvidence, } from './workspaceSyncTransferEvidence.js';
 const NOOP_CLOUD_RESOLVER = (path) => path;
@@ -13,6 +14,7 @@ const RETRY_BASE_DELAY_MS = 1_000;
 const RETRY_MAX_DELAY_MS = 5 * 60_000;
 const COMBINED_FEED_COVERED_OUTBOX_BLOCK = 'WORKSPACE_SYNC_V3_COVERED_LOCAL_OPERATIONS';
 const REPAIR_OWNERSHIP_FINGERPRINT_VERSION = 2;
+const NON_APPLYING_ACKNOWLEDGEMENT_CHECKPOINT_INTERVAL = 64;
 class WorkspaceSyncEngineServerRunnerOperationError extends Error {
     code;
     retryAfterMs;
@@ -513,7 +515,9 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                     ? 'repair'
                     : 'push';
             activeRetryKind = pushRetryKind;
-            persist({ ...checkpoint, controlState: 'pushing' });
+            if (checkpoint.controlState !== 'pushing') {
+                persist({ ...checkpoint, controlState: 'pushing' });
+            }
             let payload;
             let signature;
             if (checkpoint.pendingV2Push) {
@@ -523,6 +527,13 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                     forceAllAiProfiles: checkpoint.pendingV2Push.forceAllAiProfiles,
                     repairMode: checkpoint.pendingV2Push.repairMode,
                 };
+                if (checkpoint.pendingV2Push.preparedPlan
+                    && checkpoint.pendingV2Push.settlementVersion !== 1) {
+                    persist({
+                        ...checkpoint,
+                        pendingV2Push: upgradeLocalWorkspaceSyncPendingV2PushSettlement(checkpoint.pendingV2Push),
+                    });
+                }
             }
             else {
                 const forcedContentPaths = pushRetryKind === 'v2-content-push'
@@ -551,11 +562,13 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 persist({ ...checkpoint, pendingV2Push });
             }
             if (checkpoint.remoteHintObservedAt) {
-                persist({
+                checkpoint = {
                     ...checkpoint,
                     consecutivePushesWhilePullDue: Math.min(Number.MAX_SAFE_INTEGER, checkpoint.consecutivePushesWhilePullDue + 1),
-                });
+                };
             }
+            let persistedAcknowledgementCount = checkpoint.pendingV2Push
+                ?.acknowledgedNonApplyingBatchOperationIdentities.length || 0;
             const result = await runWorkspacePushSyncService({
                 resolveCloudAuthUrl: NOOP_CLOUD_RESOLVER,
                 workspaceId,
@@ -567,29 +580,33 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 preparedPlan: checkpoint.pendingV2Push?.preparedPlan,
                 acknowledgedNonApplyingBatchOperationIdentities: checkpoint.pendingV2Push
                     ?.acknowledgedNonApplyingBatchOperationIdentities,
+                settledBatchOperationIdentities: checkpoint.pendingV2Push?.settledBatchOperationIdentities,
                 onPreparedPlan: ({ plan, acknowledgedOperationIdentities, }) => {
                     const pendingV2Push = checkpoint.pendingV2Push;
                     if (!pendingV2Push) {
                         throw new WorkspaceSyncEngineServerRunnerOperationError('The frozen V2 push disappeared while recording its prepared plan.', 'SYNC_RUNNER_PUSH_CHECKPOINT_INVALID');
                     }
+                    const preparedPendingV2Push = {
+                        ...pendingV2Push,
+                        preparedPlan: plan,
+                        preparedPlanFingerprint: fingerprintLocalWorkspaceSyncPreparedPlan(plan),
+                        acknowledgedNonApplyingBatchOperationIdentities: [
+                            ...acknowledgedOperationIdentities,
+                        ],
+                    };
                     persist({
                         ...checkpoint,
-                        pendingV2Push: {
-                            ...pendingV2Push,
-                            preparedPlan: plan,
-                            preparedPlanFingerprint: fingerprintLocalWorkspaceSyncPreparedPlan(plan),
-                            acknowledgedNonApplyingBatchOperationIdentities: [
-                                ...acknowledgedOperationIdentities,
-                            ],
-                        },
+                        pendingV2Push: upgradeLocalWorkspaceSyncPendingV2PushSettlement(preparedPendingV2Push),
                     });
+                    persistedAcknowledgementCount =
+                        acknowledgedOperationIdentities.length;
                 },
                 onNonApplyingBatchAcknowledged: ({ acknowledgedOperationIdentities }) => {
                     const pendingV2Push = checkpoint.pendingV2Push;
                     if (!pendingV2Push) {
                         throw new WorkspaceSyncEngineServerRunnerOperationError('The frozen V2 push disappeared while recording batch progress.', 'SYNC_RUNNER_PUSH_CHECKPOINT_INVALID');
                     }
-                    persist({
+                    checkpoint = {
                         ...checkpoint,
                         pendingV2Push: {
                             ...pendingV2Push,
@@ -597,19 +614,93 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                                 ...acknowledgedOperationIdentities,
                             ],
                         },
+                    };
+                    if (acknowledgedOperationIdentities.length
+                        - persistedAcknowledgementCount
+                        >= NON_APPLYING_ACKNOWLEDGEMENT_CHECKPOINT_INTERVAL) {
+                        persist(checkpoint);
+                        persistedAcknowledgementCount =
+                            acknowledgedOperationIdentities.length;
+                    }
+                },
+                onAcceptedBatchSettled: async ({ operationIdentity, settlementIdentityFingerprint, appliedTaskUpserts, transferReceipt, pushBoundary, excludedProjections, }) => {
+                    const pendingV2Push = checkpoint.pendingV2Push;
+                    if (!pendingV2Push
+                        || pendingV2Push.settlementVersion !== 1
+                        || !pendingV2Push.settledBatchOperationIdentities
+                        || !pendingV2Push.settledBatchContributions) {
+                        throw new WorkspaceSyncEngineServerRunnerOperationError('The frozen V2 push settlement checkpoint is unavailable.', 'SYNC_RUNNER_PUSH_CHECKPOINT_INVALID');
+                    }
+                    if (pendingV2Push.settledBatchOperationIdentities.includes(operationIdentity)) {
+                        throw new WorkspaceSyncEngineServerRunnerOperationError('The accepted V2 push page was already settled locally.', 'SYNC_RUNNER_PUSH_CHECKPOINT_INVALID');
+                    }
+                    if (checkpoint.retry?.kind !== pushRetryKind) {
+                        setRetry(pushRetryKind, 'Accepted V2 push page local settlement is pending.');
+                    }
+                    const completionGroup = options.remoteServices.buildV2PushApplyCompletionGroup({
+                        workspaceId,
+                        pushBoundary,
+                        receipts: [transferReceipt],
+                    });
+                    if (!completionGroup) {
+                        throw new WorkspaceSyncEngineServerRunnerOperationError('Accepted V2 push page is missing an atomic local apply completion group.', 'SYNC_RUNNER_PUSH_APPLY_COMPLETION_INVALID');
+                    }
+                    const nextCheckpoint = {
+                        ...checkpoint,
+                        pendingV2Push: {
+                            ...checkpoint.pendingV2Push,
+                            settledBatchOperationIdentities: [
+                                ...checkpoint.pendingV2Push
+                                    .settledBatchOperationIdentities,
+                                operationIdentity,
+                            ],
+                            settledBatchContributions: [
+                                ...checkpoint.pendingV2Push
+                                    .settledBatchContributions,
+                                {
+                                    operationIdentity,
+                                    settlementIdentityFingerprint,
+                                    appliedTaskUpserts: structuredClone(appliedTaskUpserts),
+                                },
+                            ],
+                        },
+                    };
+                    const commitState = {};
+                    const applyResult = await localServices.applyV2Batch(workspaceId, appliedTaskUpserts.map((entry) => ({
+                        op: 'upsert',
+                        archived: entry.archived === true,
+                        task: entry.task,
+                        ...(entry.durableRevision
+                            ? { durableRevision: entry.durableRevision }
+                            : {}),
+                    })), {
+                        repairMode: attemptOptions.repairMode,
+                        excludedProjections,
+                        completionGroup,
+                        commitServerCheckpoint: () => {
+                            const persisted = input.persistCheckpoint(nextCheckpoint);
+                            commitState.checkpoint = structuredClone(persisted.checkpoint);
+                            return commitState.checkpoint;
+                        },
                     });
+                    if (!applyResult.ok || !commitState.checkpoint) {
+                        throw new WorkspaceSyncEngineServerRunnerOperationError(!applyResult.ok
+                            ? authoritativeV2ApplyFailureMessage(applyResult)
+                            : 'Accepted V2 push page did not commit its settlement checkpoint.', 'SYNC_RUNNER_PUSH_AUTHORITATIVE_APPLY_FAILED');
+                    }
+                    checkpoint = structuredClone(commitState.checkpoint);
                 },
             });
             onResult?.(result);
             if (!result.success) {
                 if (result.batchProgress && checkpoint.pendingV2Push) {
-                    persist({
+                    checkpoint = {
                         ...checkpoint,
                         pendingV2Push: {
                             ...checkpoint.pendingV2Push,
                             lastBatchProgress: structuredClone(result.batchProgress),
                         },
-                    });
+                    };
                 }
                 const message = pushFailureMessage(result);
                 if (isAuthFailure(result)) {
@@ -617,7 +708,19 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 }
                 fail(pushRetryKind, message, 'SYNC_RUNNER_PUSH_FAILED', result.retryAfterMs);
             }
-            for (const entry of result.appliedTaskUpserts || []) {
+            const serviceTaskUpserts = result.appliedTaskUpserts || [];
+            const pushTransferReceipts = result.pushTransferReceipts || [];
+            const settledTaskUpserts = checkpoint.pendingV2Push
+                ?.settledBatchContributions
+                ?.flatMap((entry) => entry.appliedTaskUpserts) || [];
+            const terminalTaskUpserts = pushTransferReceipts.length > 0
+                ? serviceTaskUpserts
+                : [];
+            result.appliedTaskUpserts = [
+                ...settledTaskUpserts,
+                ...terminalTaskUpserts,
+            ];
+            for (const entry of result.appliedTaskUpserts) {
                 const taskId = String(entry.task.id || '').trim();
                 const watermark = String(entry.task.updatedAt || entry.task.createdAt || '').trim();
                 if (!taskId || !watermark)
@@ -632,14 +735,6 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 result,
             });
             const syncedAt = result.syncedAt || input.now;
-            const appliedTaskUpserts = result.appliedTaskUpserts || [];
-            const pushTransferReceipts = result.pushTransferReceipts || [];
-            if (appliedTaskUpserts.length > 0) {
-                // Persist the retry obligation before entering the atomic local
-                // apply. If that transaction rolls back after its checkpoint
-                // callback, the runner resumes from this durable revision.
-                setRetry(pushRetryKind, 'Authoritative V2 push echo local commit is pending.');
-            }
             const baseNextCheckpoint = {
                 ...checkpoint,
                 controlState: 'pushing',
@@ -653,10 +748,8 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
             const nextCheckpoint = transformTerminalCheckpoint
                 ? transformTerminalCheckpoint(baseNextCheckpoint, result, signature)
                 : baseNextCheckpoint;
-            if (appliedTaskUpserts.length > 0) {
-                const abandonPushReceipts = async (errorCode) => {
-                    if (pushTransferReceipts.length === 0)
-                        return;
+            if (terminalTaskUpserts.length > 0) {
+                const abandonTerminalReceipts = async (errorCode = 'WORKSPACE_SYNC_V2_PUSH_AUTHORITATIVE_APPLY_FAILED') => {
                     try {
                         await options.remoteServices.abandonTransferReceipts({
                             workspaceId,
@@ -666,10 +759,9 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                     }
                     catch {
                         // The durable retry checkpoint remains authoritative.
-                        // The next exact replay will recover the retained or
-                        // ambiguous permit through the gateway.
                     }
                 };
+                setRetry(pushRetryKind, 'Authoritative V2 push echo local commit is pending.');
                 const completionGroup = result.pushBoundary
                     ? options.remoteServices.buildV2PushApplyCompletionGroup({
                         workspaceId,
@@ -678,13 +770,13 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                     })
                     : undefined;
                 if (!completionGroup) {
-                    await abandonPushReceipts('WORKSPACE_SYNC_V2_PUSH_APPLY_COMPLETION_INVALID');
+                    await abandonTerminalReceipts('WORKSPACE_SYNC_V2_PUSH_APPLY_COMPLETION_INVALID');
                     throw new WorkspaceSyncEngineServerRunnerOperationError('Accepted V2 push echoes are missing an atomic local apply completion group.', 'SYNC_RUNNER_PUSH_APPLY_COMPLETION_INVALID');
                 }
                 const commitState = {};
                 let applyResult;
                 try {
-                    applyResult = await localServices.applyV2Batch(workspaceId, appliedTaskUpserts.map((entry) => ({
+                    applyResult = await localServices.applyV2Batch(workspaceId, terminalTaskUpserts.map((entry) => ({
                         op: 'upsert',
                         archived: entry.archived === true,
                         task: entry.task,
@@ -692,32 +784,31 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                             ? { durableRevision: entry.durableRevision }
                             : {}),
                     })), {
-                        ...(completionGroup ? { completionGroup } : {}),
+                        repairMode: attemptOptions.repairMode,
+                        excludedProjections: result.effectiveV2ExcludedProjections,
+                        completionGroup,
                         commitServerCheckpoint: () => {
                             const persisted = input.persistCheckpoint(nextCheckpoint, {
                                 beforeCommit: beforeTerminalPersist
                                     ? () => beforeTerminalPersist(result)
                                     : undefined,
                             });
-                            commitState.checkpoint =
-                                structuredClone(persisted.checkpoint);
+                            commitState.checkpoint = structuredClone(persisted.checkpoint);
                             return commitState.checkpoint;
                         },
                     });
                 }
                 catch (error) {
-                    await abandonPushReceipts('WORKSPACE_SYNC_V2_PUSH_AUTHORITATIVE_APPLY_FAILED');
+                    await abandonTerminalReceipts();
                     throw new WorkspaceSyncEngineServerRunnerOperationError(errorMessage(error, 'Authoritative V2 push echo apply failed.'), 'SYNC_RUNNER_PUSH_AUTHORITATIVE_APPLY_FAILED');
                 }
                 if (!applyResult.ok || !commitState.checkpoint) {
-                    await abandonPushReceipts('WORKSPACE_SYNC_V2_PUSH_AUTHORITATIVE_APPLY_FAILED');
-                    throw new WorkspaceSyncEngineServerRunnerOperationError(`Authoritative V2 push echo apply failed (${applyResult.status || 0}).`, 'SYNC_RUNNER_PUSH_AUTHORITATIVE_APPLY_FAILED');
-                }
-                const committedCheckpoint = commitState.checkpoint;
-                if (!committedCheckpoint) {
-                    throw new WorkspaceSyncEngineServerRunnerOperationError('The authoritative V2 push echo apply did not commit its runner checkpoint.', 'SYNC_RUNNER_PUSH_CHECKPOINT_NOT_COMMITTED');
+                    await abandonTerminalReceipts();
+                    throw new WorkspaceSyncEngineServerRunnerOperationError(!applyResult.ok
+                        ? authoritativeV2ApplyFailureMessage(applyResult)
+                        : 'Authoritative V2 push echo did not commit the server checkpoint.', 'SYNC_RUNNER_PUSH_AUTHORITATIVE_APPLY_FAILED');
                 }
-                checkpoint = structuredClone(committedCheckpoint);
+                checkpoint = structuredClone(commitState.checkpoint);
             }
             else {
                 persist(nextCheckpoint, {

package/dist/sync/engine/workspaceSyncEngineServerSnapshotReader.js

@@ -28,6 +28,7 @@ export function toWorkspaceSyncV2PushBaseline(snapshot, currentTaxonomyStateFing
             lastPushedInitiativeWatermarks: new Map(),
             lastPushedWorkstreamIds: new Set(),
             lastPushedWorkstreamWatermarks: new Map(),
+            lastPushedPlanningIdentityWatermarks: new Map(),
             lastPushedAiProfileIds: new Set(),
             lastPushedAiProfileWatermarks: new Map(),
             lastPushedAiProfileChangeKeys: new Map(),
@@ -57,6 +58,7 @@ export function toWorkspaceSyncV2PushBaseline(snapshot, currentTaxonomyStateFing
         || snapshot.taxonomyStateFingerprint === currentTaxonomyStateFingerprint;
     const initiativeWatermarks = stringMap(snapshot.initiativeWatermarks);
     const workstreamWatermarks = stringMap(snapshot.workstreamWatermarks);
+    const planningIdentityWatermarks = stringMap(snapshot.planningIdentityWatermarks);
     const aiProfileWatermarks = stringMap(snapshot.aiProfileWatermarks);
     const documentWatermarks = stringMap(snapshot.documentWatermarks);
     const assetWatermarks = stringMap(snapshot.assetWatermarks);
@@ -76,6 +78,7 @@ export function toWorkspaceSyncV2PushBaseline(snapshot, currentTaxonomyStateFing
         lastPushedInitiativeWatermarks: initiativeWatermarks,
         lastPushedWorkstreamIds: new Set(workstreamWatermarks.keys()),
         lastPushedWorkstreamWatermarks: workstreamWatermarks,
+        lastPushedPlanningIdentityWatermarks: planningIdentityWatermarks,
         lastPushedAiProfileIds: new Set(aiProfileWatermarks.keys()),
         lastPushedAiProfileWatermarks: aiProfileWatermarks,
         lastPushedAiProfileChangeKeys: stringMap(snapshot.aiProfileChangeKeys),
@@ -146,6 +149,9 @@ export function createWorkspaceSyncEngineServerPushCandidateProvider(snapshotRea
                 taskRelationshipChangeKeys: sortedEntries(taskRelationshipChangeKeys),
                 initiativeWatermarks: sortedEntries(result.currentInitiativeWatermarks),
                 workstreamWatermarks: sortedEntries(result.currentWorkstreamWatermarks),
+                planningIdentityWatermarks: sortedEntries(result.currentPlanningIdentityWatermarks
+                    || payload.currentPlanningIdentityWatermarks
+                    || stringMap(previousBaseline?.planningIdentityWatermarks)),
                 aiProfileWatermarks: sortedEntries(result.currentAiProfileWatermarks),
                 aiProfileChangeKeys: sortedEntries(aiProfileChangeKeys),
                 taskforceAgentWatermarks: sortedEntries(result.currentTaskforceAgentWatermarks),

package/dist/sync/engine/workspaceSyncEngineTransfers.d.ts

@@ -3,7 +3,7 @@ import type { WorkspaceSyncPayload } from '../workspaceSyncModel.js';
 import type { WorkspaceSyncPhase } from '../workspaceSyncState.js';
 import type { WorkspaceSyncV3CombinedCoverageSelector } from '../v3/workspaceSyncV3CombinedWireContract.js';
 import type { WorkspaceSyncEngineRuntime } from './workspaceSyncEngineRuntime.js';
-import type { WorkspaceSyncEngineLocalServices } from './workspaceSyncEngineLocalServices.js';
+import { type WorkspaceSyncEngineLocalServices } from './workspaceSyncEngineLocalServices.js';
 import type { WorkspaceSyncEngineRemoteServices, WorkspaceSyncEngineRemoteTransferReceipt } from './workspaceSyncEngineRemoteServices.js';
 export type { PendingWorkspacePushReplay } from './workspaceSyncEngineTransferTypes.js';
 type StateSetter<T> = (value: T | ((current: T) => T)) => void;