@taskforcehq/taskforce 0.3.329 → 0.3.330

package/dist/sync/engine/workspaceSyncContentVersionStore.js

@@ -1,4 +1,4 @@
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { compareWorkspaceMutationOrdering } from '../workspaceSyncSurface.js';
 import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
 export class WorkspaceSyncContentVersionConflictError extends Error {
@@ -577,9 +577,58 @@ export class WorkspaceSyncContentVersionStore {
                 contentSha256: null,
                 sizeBytes: null,
             });
+            // Only a tombstone that's actually newly accepted (didn't early-return
+            // above as superseded/no-op) gets a provenance record — provenance
+            // tracks admission events, not every replayed/no-op call.
+            this.recordTombstoneProvenance(input);
             return this.requireHead(input);
         })();
     }
+    recordTombstoneProvenance(input) {
+        const provenance = input.provenance;
+        this.db.prepare(`
+            INSERT INTO workspace_sync_content_tombstone_provenance (
+                id, tenant_id, workspace_id, kind, logical_path, source,
+                operation_id, actor_id, source_runtime, source_updated_at,
+                repair_involved, recorded_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(randomUUID(), input.tenantId, input.workspaceId, input.kind, input.logicalPath, provenance?.source || 'unknown', provenance?.operationId || null, provenance?.actorId || null, provenance?.sourceRuntime || null, input.sourceUpdatedAt, provenance?.repairInvolved === true ? 1 : 0, input.publishedAt);
+    }
+    /** Queryable read side for tombstone provenance — most recent admission first. */
+    listTombstoneProvenance(input) {
+        const limit = Math.max(1, Math.min(500, Math.floor(Number(input.limit) || 100)));
+        const conditions = ['tenant_id = ?', 'workspace_id = ?'];
+        const params = [input.tenantId, input.workspaceId];
+        if (input.kind) {
+            conditions.push('kind = ?');
+            params.push(input.kind);
+        }
+        if (input.logicalPath) {
+            conditions.push('logical_path = ?');
+            params.push(input.logicalPath);
+        }
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM workspace_sync_content_tombstone_provenance
+            WHERE ${conditions.join(' AND ')}
+            ORDER BY recorded_at DESC
+            LIMIT ?
+        `).all(...params, limit);
+        return rows.map((row) => ({
+            id: String(row.id || ''),
+            tenantId: String(row.tenant_id || ''),
+            workspaceId: String(row.workspace_id || ''),
+            kind: row.kind === 'document' ? 'document' : 'asset',
+            logicalPath: String(row.logical_path || ''),
+            source: String(row.source || 'unknown'),
+            operationId: row.operation_id == null ? null : String(row.operation_id),
+            actorId: row.actor_id == null ? null : String(row.actor_id),
+            sourceRuntime: row.source_runtime == null ? null : String(row.source_runtime),
+            sourceUpdatedAt: String(row.source_updated_at || ''),
+            repairInvolved: Number(row.repair_involved) === 1,
+            recordedAt: String(row.recorded_at || ''),
+        }));
+    }
     resolveHead(input) {
         const head = this.getHead(input);
         return head ? { source: 'versioned', head } : { source: 'legacy' };

package/dist/sync/engine/workspaceSyncEngineLifecyclePolicy.js

@@ -25,7 +25,7 @@ export function resolveWorkspaceSyncPresentation({ enabled, phase, busy, retryAt
             summary: busy
                 ? 'Uploading this workspace to cloud for the first time.'
                 : 'Preparing the first upload to cloud.',
-            recommendedAction: 'Keep this window open while the first upload finishes. If it seems stalled, press Sync.'
+            recommendedAction: 'Keep this window open while the first upload finishes.'
         };
     }
     if (phase === 'attach-cloud') {
@@ -71,14 +71,14 @@ export function resolveWorkspaceSyncPresentation({ enabled, phase, busy, retryAt
         return {
             status: 'attention',
             summary: 'Sync hit a temporary problem and will retry automatically.',
-            recommendedAction: 'Wait for the automatic retry, or press Sync to retry now.'
+            recommendedAction: 'Wait for the automatic retry.'
         };
     }
     if (lastErrorMessage || phase === 'error') {
         return {
             status: 'attention',
             summary: 'Sync needs attention before it can continue.',
-            recommendedAction: 'Press Sync to retry. If the same error keeps returning, press Repair.'
+            recommendedAction: 'Keep sync enabled. If the same error keeps returning, press Repair.'
         };
     }
     if (pendingChanges > 0 || (durableOutbox?.pending || 0) > 0 || (durableOutbox?.inFlight || 0) > 0) {
@@ -104,14 +104,14 @@ export function resolveWorkspaceSyncPresentation({ enabled, phase, busy, retryAt
             summary: lastPushMs === null
                 ? 'This device has not completed its first cloud pull.'
                 : 'Cloud uploads are working, but this device has not completed a cloud pull.',
-            recommendedAction: 'Press Retry now. If the cloud check still does not complete, press Repair and copy the report.'
+            recommendedAction: 'Keep sync enabled. If the cloud check still does not complete, press Repair and copy the report.'
         };
     }
     if (lastErrorMs !== null && lastErrorMs > lastPullMs) {
         return {
             status: 'attention',
             summary: 'A sync issue occurred after the last successful cloud pull.',
-            recommendedAction: 'Press Retry now to verify cloud changes can still be received. If the issue returns, copy the report.'
+            recommendedAction: 'Wait for the automatic retry. If the issue returns, copy the report.'
         };
     }
     const pullIsStale = Number.isFinite(nowMs)
@@ -122,7 +122,7 @@ export function resolveWorkspaceSyncPresentation({ enabled, phase, busy, retryAt
             summary: lastPushMs !== null && lastPushMs > lastPullMs
                 ? 'Cloud uploads are succeeding, but this device has not received cloud changes recently.'
                 : 'This device has not checked for cloud changes recently.',
-            recommendedAction: 'Press Retry now to check cloud changes. If Last cloud check does not advance, press Repair and copy the report.'
+            recommendedAction: 'Keep sync enabled. If Last cloud check does not advance, press Repair and copy the report.'
         };
     }
     return {

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

@@ -1,4 +1,5 @@
 import type { WorkspaceSyncChange, WorkspaceSyncDurableTaskRevision, WorkspaceSyncTaskSnapshot } from '../workspaceSyncModel.js';
+import type { WorkspaceSyncV2ProjectionExclusion } from '../v3/workspaceSyncV2ProjectionExclusions.js';
 export declare const WORKSPACE_SYNC_ENGINE_V2_PUSH_BOUNDARY_VERSION: 1;
 /**
  * Stable attempt-wide boundary shared by every V2 push batch. Individual
@@ -18,3 +19,16 @@ export interface WorkspaceSyncEngineAppliedTaskUpsert {
 }
 export declare function workspaceSyncEngineExpectedTaskEchoIds(changes: readonly WorkspaceSyncChange[]): string[];
 export declare function parseWorkspaceSyncEngineAppliedTaskUpserts(value: unknown, expectedTaskIds: readonly string[]): WorkspaceSyncEngineAppliedTaskUpsert[];
+export declare function createWorkspaceSyncEngineV2SettlementIdentityProjection(input: {
+    operationIdentity: string;
+    changes: readonly WorkspaceSyncChange[];
+    appliedTaskUpserts: readonly WorkspaceSyncEngineAppliedTaskUpsert[];
+    excludedProjections?: readonly WorkspaceSyncV2ProjectionExclusion[];
+}): {
+    version: 1;
+    operationIdentity: string;
+    taskUpserts: Array<{
+        archived: boolean;
+        task: Record<string, unknown>;
+    }>;
+};

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/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/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>;