@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/sync/engine/workspaceSyncEngineServerRunnerOperations.js

@@ -1,5 +1,5 @@
 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';
@@ -527,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'
@@ -573,23 +580,26 @@ 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;
+                    persistedAcknowledgementCount =
+                        acknowledgedOperationIdentities.length;
                 },
                 onNonApplyingBatchAcknowledged: ({ acknowledgedOperationIdentities }) => {
                     const pendingV2Push = checkpoint.pendingV2Push;
@@ -609,8 +619,76 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                         - persistedAcknowledgementCount
                         >= NON_APPLYING_ACKNOWLEDGEMENT_CHECKPOINT_INTERVAL) {
                         persist(checkpoint);
-                        persistedAcknowledgementCount = acknowledgedOperationIdentities.length;
+                        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);
@@ -630,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)
@@ -645,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',
@@ -666,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,
@@ -679,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,
@@ -691,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,
@@ -707,34 +786,29 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                     })), {
                         repairMode: attemptOptions.repairMode,
                         excludedProjections: result.effectiveV2ExcludedProjections,
-                        ...(completionGroup ? { completionGroup } : {}),
+                        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');
+                    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');
                 }
-                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');
-                }
-                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.js

@@ -173,7 +173,7 @@ export function createWorkspaceSyncV3TransferBindings(input) {
     };
 }
 export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtimeMode, initiativeFeedActivationEnabled, combinedFeedActivationEnabled, combinedFeedCoverage, workspaceCloudSyncEnabled, currentWorkspaceId, workspaceSyncPhase, isAuthenticated, checkAuthSession, resolveCloudAuthUrl, ensureCloudWorkspaceReadyForSync, ensureWorkspaceSyncReady, handleSyncAuthFailure, clearWorkspaceRetry, clearWorkspaceIssue, isWorkspaceRetryPending, isDurableRecoveryBlockingOrdinaryPush, isExecutionAuthorized = () => true, scheduleWorkspaceSyncRetry, persistWorkspaceSyncPatchSafely, persistWorkspaceSyncPatchBestEffort, persistWorkspaceSyncWatermarksSnapshotBestEffort, refreshWorkspaceAiProfilePushBaselineFromPersistence, reportSyncEvent, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, recordWorkspaceSyncCompletion, reportWorkspaceWindowContention, refreshWorkspaceSyncMarkdownDocumentsSnapshot, refreshWorkspaceSyncAiProfilesSnapshot, refreshWorkspaceSyncAssetsSnapshot, refreshWorkspaceSyncTaxonomySnapshot, refreshWorkspaceSyncPlanningEntitiesSnapshot, refreshWorkspaceSyncDocumentReviewSessionsSnapshot, refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot, refreshWorkspaceSyncTaskforceAgentsSnapshot, refreshLocalWorkspaceTaskCollections, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, seedWorkspaceSnapshotPushBaseline, shouldSuppressAttachBootstrapPush, recordSuppressedEventIds, runtime, localServices, remoteServices, setWorkspaceSyncBusy, setUserGlobalSyncStatus, setUserGlobalSyncError, setWorkspaceLastErrorMessage, setWorkspaceLastErrorAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceSyncPendingChanges, setTasks, setArchivedTasks, now, scheduleTask, logDebug = () => undefined, notifyAiProfilesMutated = () => undefined, notifyAgentsMutated = () => undefined, notifyAgentSkillsMutated = () => undefined }) {
-    const { repairMode: workspaceRepairModeRef, forceFullAiProfilePush: workspaceForceFullAiProfilePushRef, pushInFlight: workspacePushInFlightRef, pullInFlight: workspacePullInFlightRef, pullAfterPushRequested: workspacePullAfterPushRequestedRef, pendingPushReplay: workspacePendingPushReplayRef, blockedPushSignature: workspaceBlockedPushSignatureRef, lastPushedSignature: workspaceLastPushedSignatureRef, pendingSignature: workspacePendingSignatureRef, lastPushedTaskIds: workspaceLastPushedTaskIdsRef, deletedTaskIds: workspaceDeletedTaskIdsRef, deletedTaskWatermarks: workspaceDeletedTaskWatermarksRef, pullCursor: workspacePullCursorRef, lastPushedWatermarks: workspaceLastPushedWatermarksRef, lastPushedTaskChangeKeys: workspaceLastPushedTaskChangeKeysRef, lastPushedTaskRelationshipChangeKeys: workspaceLastPushedTaskRelationshipChangeKeysRef, lastPushedTaxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef, lastPushedInitiativeIds: workspaceLastPushedInitiativeIdsRef, lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef, lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef, lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef, lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef, lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef, lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef, lastPushedDocumentPaths: workspaceLastPushedDocumentPathsRef, lastPushedDocumentWatermarks: workspaceLastPushedDocumentWatermarksRef, lastPushedAssetPaths: workspaceLastPushedAssetPathsRef, lastPushedAssetWatermarks: workspaceLastPushedAssetWatermarksRef, lastPushedDocumentReviewSessionIds: workspaceLastPushedDocumentReviewSessionIdsRef, lastPushedDocumentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef, lastPushedDocumentReviewCommentIds: workspaceLastPushedDocumentReviewCommentIdsRef, lastPushedDocumentReviewCommentWatermarks: workspaceLastPushedDocumentReviewCommentWatermarksRef, lastPushedAnnotatedAttachmentSessionIds: workspaceLastPushedAnnotatedAttachmentSessionIdsRef, lastPushedAnnotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, lastPushedTaskforceAgentIds: workspaceLastPushedTaskforceAgentIdsRef, lastPushedTaskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef, lastPushedTaskforceAgentSkillIds: workspaceLastPushedTaskforceAgentSkillIdsRef, lastPushedTaskforceAgentSkillWatermarks: workspaceLastPushedTaskforceAgentSkillWatermarksRef, lastPushedAgentConversationIds: workspaceLastPushedAgentConversationIdsRef, lastPushedAgentConversationWatermarks: workspaceLastPushedAgentConversationWatermarksRef, lastPushedTaskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef, baselineResetReason: workspaceBaselineResetReasonRef, captureAttachBootstrapBaseline: workspaceCaptureAttachBootstrapBaselineRef, startupFullReconcileRan: workspaceStartupFullReconcileRanRef, startupFullReconcileRequested: workspaceStartupFullReconcileRequestedRef, fullReconcileInFlight: workspaceFullReconcileInFlightRef, bootstrapLastProgressAtMs: bootstrapLastProgressAtRef, realtimeSuppressedEventQueue: realtimeSuppressedEventQueueRef, } = runtime;
+    const { repairMode: workspaceRepairModeRef, forceFullAiProfilePush: workspaceForceFullAiProfilePushRef, pushInFlight: workspacePushInFlightRef, pullInFlight: workspacePullInFlightRef, pullAfterPushRequested: workspacePullAfterPushRequestedRef, pendingPushReplay: workspacePendingPushReplayRef, blockedPushSignature: workspaceBlockedPushSignatureRef, lastPushedSignature: workspaceLastPushedSignatureRef, pendingSignature: workspacePendingSignatureRef, lastPushedTaskIds: workspaceLastPushedTaskIdsRef, deletedTaskIds: workspaceDeletedTaskIdsRef, deletedTaskWatermarks: workspaceDeletedTaskWatermarksRef, pullCursor: workspacePullCursorRef, lastPushedWatermarks: workspaceLastPushedWatermarksRef, lastPushedTaskChangeKeys: workspaceLastPushedTaskChangeKeysRef, lastPushedTaskRelationshipChangeKeys: workspaceLastPushedTaskRelationshipChangeKeysRef, lastPushedTaxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef, lastPushedInitiativeIds: workspaceLastPushedInitiativeIdsRef, lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef, lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef, lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef, lastPushedPlanningIdentityWatermarks: workspaceLastPushedPlanningIdentityWatermarksRef, lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef, lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef, lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef, lastPushedDocumentPaths: workspaceLastPushedDocumentPathsRef, lastPushedDocumentWatermarks: workspaceLastPushedDocumentWatermarksRef, lastPushedAssetPaths: workspaceLastPushedAssetPathsRef, lastPushedAssetWatermarks: workspaceLastPushedAssetWatermarksRef, lastPushedDocumentReviewSessionIds: workspaceLastPushedDocumentReviewSessionIdsRef, lastPushedDocumentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef, lastPushedDocumentReviewCommentIds: workspaceLastPushedDocumentReviewCommentIdsRef, lastPushedDocumentReviewCommentWatermarks: workspaceLastPushedDocumentReviewCommentWatermarksRef, lastPushedAnnotatedAttachmentSessionIds: workspaceLastPushedAnnotatedAttachmentSessionIdsRef, lastPushedAnnotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, lastPushedTaskforceAgentIds: workspaceLastPushedTaskforceAgentIdsRef, lastPushedTaskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef, lastPushedTaskforceAgentSkillIds: workspaceLastPushedTaskforceAgentSkillIdsRef, lastPushedTaskforceAgentSkillWatermarks: workspaceLastPushedTaskforceAgentSkillWatermarksRef, lastPushedAgentConversationIds: workspaceLastPushedAgentConversationIdsRef, lastPushedAgentConversationWatermarks: workspaceLastPushedAgentConversationWatermarksRef, lastPushedTaskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef, baselineResetReason: workspaceBaselineResetReasonRef, captureAttachBootstrapBaseline: workspaceCaptureAttachBootstrapBaselineRef, startupFullReconcileRan: workspaceStartupFullReconcileRanRef, startupFullReconcileRequested: workspaceStartupFullReconcileRequestedRef, fullReconcileInFlight: workspaceFullReconcileInFlightRef, bootstrapLastProgressAtMs: bootstrapLastProgressAtRef, realtimeSuppressedEventQueue: realtimeSuppressedEventQueueRef, } = runtime;
     const scheduledTasks = new Map();
     let disposed = false;
     const scheduleCoordinatorTask = (key, callback, delayMs) => {
@@ -467,6 +467,8 @@ export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtim
             workspaceLastPushedInitiativeWatermarksRef.current = new Map(pushResult.currentInitiativeWatermarks);
             workspaceLastPushedWorkstreamIdsRef.current = new Set(pushResult.currentWorkstreamIds);
             workspaceLastPushedWorkstreamWatermarksRef.current = new Map(pushResult.currentWorkstreamWatermarks);
+            workspaceLastPushedPlanningIdentityWatermarksRef.current = new Map(pushResult.currentPlanningIdentityWatermarks
+                || payload.currentPlanningIdentityWatermarks);
             workspaceLastPushedAiProfileIdsRef.current = new Set(pushResult.currentAiProfileIds);
             workspaceLastPushedAiProfileWatermarksRef.current = new Map(pushResult.currentAiProfileWatermarks);
             workspaceLastPushedAiProfileChangeKeysRef.current = pushResult.currentAiProfileChangeKeys

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

@@ -12,6 +12,7 @@ type SyncCore = TaskforceCore & TaskforceSyncCapable;
 type ContentSyncState = ReturnType<typeof createContentSyncState>;
 export interface WorkspaceSyncV2DispatchOptions {
     allowReferenceNumberReassignment?: boolean;
+    actorUserId?: string;
     workspaceMembers?: WorkspaceSyncWorkspaceMemberSnapshot[];
     coexistenceDirection?: TaskMetadataCoexistenceDirection;
     assertedActiveV3TaskMetadataIds?: ReadonlySet<string>;

package/dist/sync/engine/workspaceSyncV2ChangeDispatcher.js

@@ -7,6 +7,7 @@ import { WorkspaceSyncDurabilityStore } from '../v3/syncDurabilityStore.js';
 import { assertWorkspaceSyncV2TaskCarrierRootsExist, prepareWorkspaceSyncV2TaskCarriers, } from '../v3/workspaceSyncV2ProjectionExclusions.js';
 import { resolveV3OwnedTaskDeleteIds, resolveV3OwnedTaskLifecycleIds, resolveV3OwnedTaskMetadataIds, resolveV3OwnedTaskReopenAssigneeIds, resolveV3OwnedTaskTaxonomyIds, } from '../v3/taskMetadataCoexistence.js';
 import { assertWorkspaceSyncV2MetadataOnlyApplyPreflight, } from './workspaceSyncEngineLocalApply.js';
+import { assertTaskforceAgentSyncPushAccess } from '../taskforceAgentSyncAuthorization.js';
 function createSyncRouteError(message, details, options) {
     const error = new Error(message);
     error.code = options?.code || 'SYNC_APPLY_FAILED';
@@ -132,6 +133,14 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
             normalizeTaskEventSyncPayload,
             recordSyncDiagnostic,
         });
+        if (options.coexistenceDirection === 'cloud-push') {
+            assertTaskforceAgentSyncPushAccess({
+                agents: applyModel.collaboration.incomingTaskforceAgents.values(),
+                actorUserId: String(options.actorUserId || '').trim() || null,
+                hasUserFeatureGrant: (userId, featureKey) => core.hasUserFeatureGrant(userId, featureKey),
+                createSyncRouteError,
+            });
+        }
         if (metadataOnly) {
             assertWorkspaceSyncV2MetadataOnlyApplyPreflight(incomingChanges);
         }
@@ -304,6 +313,11 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                 incomingAgentRoles: applyModel.collaboration.incomingAgentRoles,
                 incomingTaskforceAgentSkills: applyModel.collaboration.incomingTaskforceAgentSkills,
                 incomingAgentConversations: applyModel.collaboration.incomingAgentConversations,
+                ...(options.coexistenceDirection === 'cloud-push' ? {
+                    taskforceAgentPushActorUserId: String(options.actorUserId || '').trim() || null,
+                    taskforceAgentPushAccessPreflighted: true,
+                } : {}),
+                coexistenceDirection: options.coexistenceDirection,
                 recordSyncDiagnostic,
                 createSyncRouteError,
             });
@@ -633,6 +647,18 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                 sourceUpdatedAt: intent.sourceUpdatedAt,
                 publishedAt: now().toISOString(),
                 deletedAt: intent.sourceUpdatedAt,
+                // This dispatch path only ever runs from an explicit document-delete/
+                // asset-delete WorkspaceSyncChange (see workspaceSyncV2PreparedContent.ts)
+                // — never from workspace repair, which is intentionally routed to a
+                // durable retry obligation instead (see workspaceRepair.ts) rather than
+                // ever reaching this admission boundary. operationId/actorId are not yet
+                // threaded through the WorkspaceSyncChange wire format from origin to this
+                // layer — see the type's doc comment.
+                provenance: {
+                    source: 'explicit-delete',
+                    sourceRuntime: 'server',
+                    repairInvolved: false,
+                },
             });
             if (tombstone.versionId !== null
                 || tombstone.sourceUpdatedAt !== intent.sourceUpdatedAt
@@ -748,6 +774,11 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                     incomingAgentRoles: applyModel.collaboration.incomingAgentRoles,
                     incomingTaskforceAgentSkills: applyModel.collaboration.incomingTaskforceAgentSkills,
                     incomingAgentConversations: applyModel.collaboration.incomingAgentConversations,
+                    ...(options.coexistenceDirection === 'cloud-push' ? {
+                        taskforceAgentPushActorUserId: String(options.actorUserId || '').trim() || null,
+                        taskforceAgentPushAccessPreflighted: true,
+                    } : {}),
+                    coexistenceDirection: options.coexistenceDirection,
                     recordSyncDiagnostic,
                     createSyncRouteError,
                 });

package/dist/sync/syncApplyHandlers.d.ts

@@ -255,6 +255,9 @@ export declare function applyCollaborationSyncChanges(input: {
     incomingAgentRoles?: Map<string, WorkspaceSyncAgentRoleSnapshot>;
     incomingTaskforceAgentSkills?: Map<string, WorkspaceSyncTaskforceAgentSkillSnapshot>;
     incomingAgentConversations?: Map<string, WorkspaceSyncAgentConversationSnapshot>;
+    taskforceAgentPushActorUserId?: string | null;
+    taskforceAgentPushAccessPreflighted?: boolean;
+    coexistenceDirection?: 'local-pull' | 'cloud-push';
     recordSyncDiagnostic: RecordSyncDiagnostic;
     createSyncRouteError: CreateSyncRouteError;
 }): void;

package/dist/sync/syncApplyHandlers.js

@@ -18,6 +18,7 @@ import { TaskforceAgentStore } from '../storage/taskforceAgentStore.js';
 import { TaskforceAgentSkillStore } from '../storage/taskforceAgentSkillStore.js';
 import { TaskforceAgentConversationStore } from '../storage/taskforceAgentConversationStore.js';
 import { AgentRoleStore } from '../storage/agentRoleStore.js';
+import { assertTaskforceAgentSyncPushAccess } from './taskforceAgentSyncAuthorization.js';
 import { preserveV3OwnedTaskRoot, preserveV3OwnedTaskLifecycle, preserveV3OwnedTaskMetadata, preserveV3OwnedTaskReopenAssignee, preserveV3OwnedTaskTaxonomy, } from './v3/taskMetadataCoexistence.js';
 function createIncomingApplyModel() {
     return {
@@ -1052,7 +1053,15 @@ export async function applyContentSyncChanges(input) {
     }
 }
 export function applyCollaborationSyncChanges(input) {
-    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, incomingTaskforceAgents = new Map(), incomingAgentRoles = new Map(), incomingTaskforceAgentSkills = new Map(), incomingAgentConversations = new Map(), recordSyncDiagnostic, createSyncRouteError, } = input;
+    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, incomingTaskforceAgents = new Map(), incomingAgentRoles = new Map(), incomingTaskforceAgentSkills = new Map(), incomingAgentConversations = new Map(), taskforceAgentPushActorUserId, taskforceAgentPushAccessPreflighted = false, coexistenceDirection, recordSyncDiagnostic, createSyncRouteError, } = input;
+    if (taskforceAgentPushActorUserId !== undefined && !taskforceAgentPushAccessPreflighted) {
+        assertTaskforceAgentSyncPushAccess({
+            agents: incomingTaskforceAgents.values(),
+            actorUserId: taskforceAgentPushActorUserId,
+            hasUserFeatureGrant: (userId, featureKey) => core.hasUserFeatureGrant(userId, featureKey),
+            createSyncRouteError,
+        });
+    }
     if (incomingDocumentReviewSessions.size > 0) {
         for (const session of incomingDocumentReviewSessions.values()) {
             try {
@@ -1132,6 +1141,48 @@ export function applyCollaborationSyncChanges(input) {
                         .digest('hex')
                     : '';
                 const metadataCompare = resolveSyncConflictOrdering(comment.updatedAt, String(existing?.updatedAt || '').trim(), incomingTieBreak, existingTieBreak);
+                const parentCommentConflict = Boolean(existing
+                    && comment.parentCommentId !== undefined
+                    && comment.parentCommentId !== existing.parentCommentId);
+                const nonThreadFieldsMatch = Boolean(existing
+                    && comment.sessionId === existing.sessionId
+                    && comment.body === existing.body
+                    && JSON.stringify(comment.anchor ?? null) === JSON.stringify(existing.anchor ?? null)
+                    && comment.order === existing.order
+                    && (comment.authorActorId ?? null) === (existing.authorActorId ?? null)
+                    && (comment.updatedByActorId ?? null) === (existing.updatedByActorId ?? null)
+                    && (comment.deletedByActorId ?? null) === (existing.deletedByActorId ?? null)
+                    && comment.createdAt === existing.createdAt
+                    && comment.updatedAt === existing.updatedAt
+                    && (comment.deletedAt ?? null) === (existing.deletedAt ?? null));
+                const incomingIsLegacyProjectedRoot = Boolean(nonThreadFieldsMatch
+                    && comment.parentCommentId === null
+                    && comment.threadStatus === 'open'
+                    && comment.threadStatusUpdatedAt === comment.createdAt
+                    && !comment.resolvedAt
+                    && !comment.resolvedByActorId);
+                const existingIsLegacyProjectedRoot = Boolean(nonThreadFieldsMatch
+                    && existing
+                    && existing.parentCommentId === null
+                    && existing.threadStatus === 'open'
+                    && existing.threadStatusUpdatedAt === existing.createdAt
+                    && !existing.resolvedAt
+                    && !existing.resolvedByActorId);
+                const preserveLocalReplyParent = parentCommentConflict
+                    && coexistenceDirection === 'local-pull'
+                    && Boolean(existing?.parentCommentId)
+                    && incomingIsLegacyProjectedRoot;
+                const reconcileAuthoritativeParent = parentCommentConflict
+                    && coexistenceDirection === 'local-pull'
+                    && !preserveLocalReplyParent;
+                const reconcileLegacyCloudRoot = parentCommentConflict
+                    && coexistenceDirection === 'cloud-push'
+                    && existingIsLegacyProjectedRoot
+                    && Boolean(comment.parentCommentId);
+                const applyIncomingMetadata = metadataCompare >= 0
+                    && !(parentCommentConflict
+                        && coexistenceDirection === 'cloud-push'
+                        && !reconcileLegacyCloudRoot);
                 const incomingLifecycleTieBreak = createHash('sha256')
                     .update(JSON.stringify({
                     threadStatus: comment.threadStatus,
@@ -1151,28 +1202,43 @@ export function applyCollaborationSyncChanges(input) {
                 const lifecycleCompare = comment.threadStatusUpdatedAt === undefined
                     ? -1
                     : resolveSyncConflictOrdering(String(comment.threadStatusUpdatedAt || '').trim(), String(existing?.threadStatusUpdatedAt || '').trim(), incomingLifecycleTieBreak, existingLifecycleTieBreak);
-                if (metadataCompare < 0 && lifecycleCompare < 0)
+                if (metadataCompare < 0
+                    && lifecycleCompare < 0
+                    && !reconcileAuthoritativeParent
+                    && !reconcileLegacyCloudRoot)
                     continue;
-                core.upsertDocumentReviewCommentForSync({
+                const commentForSync = {
                     id: comment.id,
                     tenantId: core.getTenantId(),
                     workspaceId,
-                    sessionId: metadataCompare >= 0 ? comment.sessionId : existing.sessionId,
-                    body: metadataCompare >= 0 ? comment.body : existing.body,
-                    anchor: (metadataCompare >= 0 ? comment.anchor : existing.anchor),
-                    order: metadataCompare >= 0 ? comment.order : existing.order,
-                    authorActorId: metadataCompare >= 0 ? comment.authorActorId : existing.authorActorId,
-                    updatedByActorId: metadataCompare >= 0 ? comment.updatedByActorId : existing.updatedByActorId,
-                    deletedByActorId: metadataCompare >= 0 ? comment.deletedByActorId : existing.deletedByActorId,
-                    parentCommentId: metadataCompare >= 0 ? comment.parentCommentId : existing.parentCommentId,
+                    sessionId: applyIncomingMetadata ? comment.sessionId : existing.sessionId,
+                    body: applyIncomingMetadata ? comment.body : existing.body,
+                    anchor: (applyIncomingMetadata ? comment.anchor : existing.anchor),
+                    order: applyIncomingMetadata ? comment.order : existing.order,
+                    authorActorId: applyIncomingMetadata ? comment.authorActorId : existing.authorActorId,
+                    updatedByActorId: applyIncomingMetadata ? comment.updatedByActorId : existing.updatedByActorId,
+                    deletedByActorId: applyIncomingMetadata ? comment.deletedByActorId : existing.deletedByActorId,
+                    parentCommentId: preserveLocalReplyParent
+                        ? existing.parentCommentId
+                        : reconcileAuthoritativeParent || reconcileLegacyCloudRoot || applyIncomingMetadata
+                            ? comment.parentCommentId
+                            : existing.parentCommentId,
                     threadStatus: lifecycleCompare >= 0 ? comment.threadStatus : undefined,
                     threadStatusUpdatedAt: lifecycleCompare >= 0 ? comment.threadStatusUpdatedAt : undefined,
                     resolvedAt: lifecycleCompare >= 0 ? comment.resolvedAt : undefined,
                     resolvedByActorId: lifecycleCompare >= 0 ? comment.resolvedByActorId : undefined,
-                    createdAt: metadataCompare >= 0 ? comment.createdAt : existing.createdAt,
-                    updatedAt: metadataCompare >= 0 ? comment.updatedAt : existing.updatedAt,
-                    deletedAt: metadataCompare >= 0 ? comment.deletedAt : existing.deletedAt,
-                });
+                    createdAt: applyIncomingMetadata ? comment.createdAt : existing.createdAt,
+                    updatedAt: applyIncomingMetadata ? comment.updatedAt : existing.updatedAt,
+                    deletedAt: applyIncomingMetadata ? comment.deletedAt : existing.deletedAt,
+                };
+                if (reconcileAuthoritativeParent || reconcileLegacyCloudRoot) {
+                    core.upsertDocumentReviewCommentForSync(commentForSync, {
+                        allowAuthoritativeThreadReconciliation: true,
+                    });
+                }
+                else {
+                    core.upsertDocumentReviewCommentForSync(commentForSync);
+                }
                 if (comment.parentCommentId) {
                     const rootExists = core.listDocumentReviewCommentsForSync({
                         workspaceId,

package/dist/sync/syncService.d.ts

@@ -52,6 +52,12 @@ export interface WorkspacePushSyncInput {
     remoteServices?: WorkspaceSyncEngineRemoteServices;
     localServices?: Pick<WorkspaceSyncEngineLocalServices, 'readPushOwnership'>;
     acknowledgedNonApplyingBatchOperationIdentities?: readonly string[];
+    /**
+     * Server-owned pages whose remote receipt, authoritative task echo, and
+     * runner checkpoint contribution committed atomically. Browser callers
+     * must not use this recovery boundary.
+     */
+    settledBatchOperationIdentities?: readonly string[];
     preparedPlan?: WorkspacePushPreparedPlan | null;
     onPreparedPlan?: (input: {
         plan: WorkspacePushPreparedPlan;
@@ -62,6 +68,14 @@ export interface WorkspacePushSyncInput {
         operationIdentity: string;
         acknowledgedOperationIdentities: readonly string[];
     }) => void | Promise<void>;
+    onAcceptedBatchSettled?: (input: {
+        operationIdentity: string;
+        settlementIdentityFingerprint: string;
+        appliedTaskUpserts: WorkspacePushSyncResult['appliedTaskUpserts'];
+        transferReceipt: WorkspaceSyncEngineRemoteTransferReceipt;
+        pushBoundary: WorkspaceSyncEngineV2PushBoundary;
+        excludedProjections?: readonly WorkspaceSyncV2ProjectionExclusion[];
+    }) => void | Promise<void>;
 }
 export interface WorkspacePushSyncResult {
     success: boolean;
@@ -90,6 +104,7 @@ export interface WorkspacePushSyncResult {
     currentInitiativeWatermarks: Map<string, string>;
     currentWorkstreamIds: Set<string>;
     currentWorkstreamWatermarks: Map<string, string>;
+    currentPlanningIdentityWatermarks?: Map<string, string>;
     currentAiProfileIds: Set<string>;
     currentAiProfileWatermarks: Map<string, string>;
     currentAiProfileChangeKeys?: Map<string, string>;