@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/sync/coordinator/localSyncExecutionPermitStore.js

@@ -21,6 +21,8 @@ const NON_APPLYING_OPERATION_CLASSES = new Set([
 const MAX_DRAIN_INSPECTION_LIMIT = 500;
 export const LOCAL_SYNC_PERMIT_RETENTION_MIN_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 export const LOCAL_SYNC_PERMIT_RETENTION_SOFT_LIMIT = 1_000;
+export const LOCAL_SYNC_PERMIT_RETENTION_HARD_LIMIT = 10_000;
+export const LOCAL_SYNC_OBLIGATION_RETENTION_HARD_LIMIT = 2_000;
 export const LOCAL_SYNC_PERMIT_RETENTION_DELETE_BATCH = 250;
 export const LOCAL_SYNC_PERMIT_RETENTION_SWEEP_LIMIT = 5_000;
 const LOCAL_SYNC_PERMIT_RETENTION_CHECK_INTERVAL_MS = 60 * 60 * 1000;
@@ -166,11 +168,29 @@ export class LocalSyncExecutionPermitStore {
             FROM local_sync_recovery_obligations
             WHERE workspace_id = ? AND resolved_at IS NULL
         `).get(workspaceId);
+        const terminalHistory = this.db.prepare(`
+            SELECT COUNT(*) AS count, MIN(completed_at) AS oldest_at
+            FROM local_sync_execution_permits
+            WHERE workspace_id = ?
+              AND state IN ('released', 'abandoned-clean', 'abandoned-reconcile-required')
+              AND completed_at IS NOT NULL
+        `).get(workspaceId);
+        const resolvedHistory = this.db.prepare(`
+            SELECT COUNT(*) AS count, MIN(resolved_at) AS oldest_at
+            FROM local_sync_recovery_obligations
+            WHERE workspace_id = ? AND resolved_at IS NOT NULL
+        `).get(workspaceId);
         return {
             active,
             byState,
             recoveryObligations: Number(obligation?.count || 0),
             localCommitInvariantViolation: this.invariantBlockedWorkspaces.has(workspaceId),
+            history: {
+                terminalPermits: Number(terminalHistory?.count || 0),
+                oldestTerminalPermitAt: terminalHistory?.oldest_at || null,
+                resolvedRecoveryObligations: Number(resolvedHistory?.count || 0),
+                oldestResolvedRecoveryObligationAt: resolvedHistory?.oldest_at || null,
+            },
         };
     }
     inspectGenerationDrain(input) {
@@ -417,6 +437,42 @@ export class LocalSyncExecutionPermitStore {
             });
         })();
     }
+    renewAcceptedApplyCompletion(input) {
+        return this.db.transaction(() => {
+            const current = this.requirePermit(input.permitId);
+            this.assertFence(current, input);
+            if (current.ownerMode !== input.ownerMode) {
+                throw new LocalSyncExecutionPermitError(`Execution permit ${input.permitId} belongs to ${current.ownerMode}, not ${input.ownerMode}.`, 'SYNC_COORDINATOR_PERMIT_IDENTITY_CONFLICT');
+            }
+            if (current.state !== 'gateway-complete-awaiting-apply'
+                || current.upstreamDisposition !== 'accepted') {
+                throw new LocalSyncExecutionPermitError(`Execution permit ${input.permitId} has no accepted apply completion to renew.`, 'SYNC_COORDINATOR_PERMIT_STATE_CONFLICT');
+            }
+            const now = this.now();
+            const deadlineMs = Date.parse(input.deadlineAt);
+            if (!Number.isFinite(deadlineMs)
+                || deadlineMs <= Date.parse(now)
+                || deadlineMs <= Date.parse(current.deadlineAt)) {
+                throw new LocalSyncExecutionPermitError(`Execution permit ${input.permitId} renewal deadline is invalid.`, 'SYNC_COORDINATOR_PERMIT_EXPIRED');
+            }
+            const result = this.db.prepare(`
+                UPDATE local_sync_execution_permits
+                SET deadline_at = ?,
+                    last_transition_at = ?
+                WHERE permit_id = ?
+                  AND workspace_id = ?
+                  AND coordinator_generation = ?
+                  AND server_instance_id = ?
+                  AND owner_mode = ?
+                  AND state = 'gateway-complete-awaiting-apply'
+                  AND upstream_disposition = 'accepted'
+            `).run(input.deadlineAt, now, input.permitId, input.workspaceId, input.coordinatorGeneration, input.serverInstanceId, input.ownerMode);
+            if (Number(result?.changes || 0) !== 1) {
+                throw new LocalSyncExecutionPermitError(`Execution permit ${input.permitId} changed before its renewal committed.`, 'SYNC_COORDINATOR_PERMIT_STATE_CONFLICT');
+            }
+            return this.read(input.permitId);
+        })();
+    }
     completeAcceptedV3Dispatch(input, applyAuthoritativeAndAck) {
         return this.db.transaction(() => {
             const current = this.requirePermit(input.permitId);
@@ -563,9 +619,15 @@ export class LocalSyncExecutionPermitStore {
             if (current.state === 'local-commit-entered') {
                 throw new LocalSyncExecutionPermitError(`Execution permit ${input.permitId} is owned by the server local commit.`, 'SYNC_COORDINATOR_PERMIT_STATE_CONFLICT');
             }
+            const cleanReadFailure = input.readResponseUnavailableBeforeApply === true
+                && input.errorCode === 'SYNC_COORDINATOR_GATEWAY_REQUEST_FAILED'
+                && current.state === 'gateway-complete-awaiting-apply'
+                && current.upstreamDisposition === 'unknown'
+                && (current.operationClass === 'pull' || current.operationClass === 'repair');
             const clean = current.state === 'issued-idle'
                 || (current.state === 'gateway-complete-awaiting-apply'
-                    && current.upstreamDisposition === 'rejected');
+                    && current.upstreamDisposition === 'rejected')
+                || cleanReadFailure;
             const disposition = current.upstreamDisposition === 'accepted'
                 ? 'accepted'
                 : current.upstreamDisposition === 'rejected'
@@ -677,19 +739,14 @@ export class LocalSyncExecutionPermitStore {
                 WHERE resolved_at IS NOT NULL
                 ORDER BY resolved_at DESC, obligation_id DESC
             `).all().map(mapObligation);
-            const protectedObligationIds = new Set(resolvedObligations
-                .slice(0, LOCAL_SYNC_PERMIT_RETENTION_SOFT_LIMIT)
-                .map((obligation) => obligation.obligationId));
-            for (const obligation of resolvedObligations) {
-                if (obligation.resolvedAt && obligation.resolvedAt >= cutoff) {
-                    protectedObligationIds.add(obligation.obligationId);
-                }
-            }
+            const obligationAgeDeleteCount = Math.max(0, resolvedObligations.length - LOCAL_SYNC_PERMIT_RETENTION_SOFT_LIMIT);
+            const obligationHardDeleteCount = Math.max(0, resolvedObligations.length - LOCAL_SYNC_OBLIGATION_RETENTION_HARD_LIMIT);
             const obligationCandidates = resolvedObligations
-                .filter((obligation) => (obligation.resolvedAt
-                && obligation.resolvedAt < cutoff
-                && !protectedObligationIds.has(obligation.obligationId)))
+                .slice()
                 .reverse()
+                .filter((obligation, index) => (index < obligationHardDeleteCount
+                || (index < obligationAgeDeleteCount
+                    && Boolean(obligation.resolvedAt && obligation.resolvedAt < cutoff))))
                 .slice(0, boundedDeleteLimit);
             const removeObligation = this.db.prepare(`
                 DELETE FROM local_sync_recovery_obligations
@@ -707,14 +764,7 @@ export class LocalSyncExecutionPermitStore {
                   AND completed_at IS NOT NULL
                 ORDER BY completed_at DESC, permit_id DESC
             `).all().map(mapPermit);
-            const protectedPermitIds = new Set(terminalPermits
-                .slice(0, LOCAL_SYNC_PERMIT_RETENTION_SOFT_LIMIT)
-                .map((permit) => permit.permitId));
-            for (const permit of terminalPermits) {
-                if (permit.completedAt && permit.completedAt >= cutoff) {
-                    protectedPermitIds.add(permit.permitId);
-                }
-            }
+            const protectedPermitIds = new Set();
             const referencedPermitRows = this.db.prepare(`
                 SELECT permit_id
                 FROM local_sync_recovery_obligations
@@ -723,11 +773,15 @@ export class LocalSyncExecutionPermitStore {
                 if (row.permit_id)
                     protectedPermitIds.add(row.permit_id);
             }
+            const permitAgeDeleteCount = Math.max(0, terminalPermits.length - LOCAL_SYNC_PERMIT_RETENTION_SOFT_LIMIT);
+            const permitHardDeleteCount = Math.max(0, terminalPermits.length - LOCAL_SYNC_PERMIT_RETENTION_HARD_LIMIT);
             const permitCandidates = terminalPermits
-                .filter((permit) => (permit.completedAt
-                && permit.completedAt < cutoff
-                && !protectedPermitIds.has(permit.permitId)))
+                .slice()
                 .reverse()
+                .filter((permit, index) => (!protectedPermitIds.has(permit.permitId)
+                && (index < permitHardDeleteCount
+                    || (index < permitAgeDeleteCount
+                        && Boolean(permit.completedAt && permit.completedAt < cutoff)))))
                 .slice(0, boundedDeleteLimit);
             const removePermit = this.db.prepare(`
                 DELETE FROM local_sync_execution_permits

package/dist/sync/coordinator/localWorkspaceSyncRunner.js

@@ -17,6 +17,10 @@ const RUNNER_COMMANDS = new Set([
 ]);
 const SCHEDULED_RETRY_BASE_DELAY_MS = 1_000;
 const SCHEDULED_RETRY_MAX_DELAY_MS = 5 * 60_000;
+const CONTENT_PREREQUISITE_BYPASSED_RETRY_KINDS = new Set([
+    'pull',
+    'repair',
+]);
 function cloneCheckpoint(checkpoint) {
     return JSON.parse(canonicalWorkspaceSyncJson(checkpoint));
 }
@@ -159,7 +163,7 @@ export class LocalWorkspaceSyncRunner {
         if (!this.context || this.terminated || !this.acceptingWork) {
             return Promise.resolve();
         }
-        return this.enqueue(async () => this.runInspection(this.options.operations.pushContentPrerequisite, { bypassRetryKind: 'repair' }));
+        return this.enqueue(async () => this.runInspection(this.options.operations.pushContentPrerequisite, { bypassRetryKinds: CONTENT_PREREQUISITE_BYPASSED_RETRY_KINDS }));
     }
     observeRemoteHint(observedAt = this.now()) {
         if (!this.context || this.terminated || !this.acceptingWork) {
@@ -476,7 +480,7 @@ export class LocalWorkspaceSyncRunner {
         if (!state.checkpoint.syncEnabled || !this.hasExactCapability(context))
             return;
         if (state.checkpoint.retry
-            && state.checkpoint.retry.kind !== options.bypassRetryKind
+            && !options.bypassRetryKinds?.has(state.checkpoint.retry.kind)
             && Date.parse(state.checkpoint.retry.retryAt) > Date.parse(this.now())) {
             this.schedulePersistedRetry(state, this.lifecycleToken);
             return;

package/dist/sync/coordinator/workspaceSyncTransportGateway.js

@@ -500,10 +500,11 @@ export function workspaceSyncGatewayTimeoutMs(operation) {
     if (operation.type === 'initiative-repair'
         || operation.type === 'combined-repair'
         || operation.type === 'v3-feed-repair'
-        || (operation.type === 'push' && operation.repairMode === true)
-        || (operation.type === 'pull' && operation.repairMode === true)
         || (operation.type === 'v3-feed'
             && (operation.forceRepair === true || Boolean(operation.repairCursor))))
+        return 75_000;
+    if ((operation.type === 'push' && operation.repairMode === true)
+        || (operation.type === 'pull' && operation.repairMode === true))
         return 180_000;
     if (operation.type === 'push'
         || operation.type === 'bootstrap-push')
@@ -638,6 +639,7 @@ const CHANGE_FIELDS = {
     'task-relationship-delete': { allowed: ['op', 'relationship'], required: ['relationship'], objectField: 'relationship' },
     'initiative-upsert': { allowed: ['op', 'initiative'], required: ['initiative'], objectField: 'initiative' },
     'workstream-upsert': { allowed: ['op', 'workstream'], required: ['workstream'], objectField: 'workstream' },
+    'planning-identity-upsert': { allowed: ['op', 'identity'], required: ['identity'], objectField: 'identity' },
     'taxonomy-upsert': { allowed: ['op', 'taxonomies', 'taxonomyState', 'updatedAt', 'durableRevision'], required: ['updatedAt'] },
     'ai-profile-upsert': { allowed: ['op', 'profile'], required: ['profile'], objectField: 'profile' },
     'document-upsert': { allowed: [

package/dist/sync/engine/workspaceSyncEngineBrowserGatewayRemoteServices.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,
+    };
+}
 async function decodeGatewayResponse(response, nowMs) {
     const rawText = await response.text();
     let data = {};
@@ -405,10 +417,12 @@ export function createBrowserGatewayWorkspaceSyncEngineRemoteServices(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,
             });
         },
@@ -510,6 +524,10 @@ export function createBrowserGatewayWorkspaceSyncEngineRemoteServices(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/workspaceSyncEngineLocalServices.d.ts

@@ -24,6 +24,10 @@ export interface WorkspaceSyncEngineV2ApplyOptions {
 export interface WorkspaceSyncEngineV3ApplyOptions {
     completionGroup?: WorkspaceSyncEngineTransferCompletionGroup;
 }
+export declare function authoritativeV2ApplyFailureMessage(input: {
+    status?: number;
+    data?: unknown;
+}): string;
 /**
  * Local-runtime operations used by the workspace sync engine.
  *

package/dist/sync/engine/workspaceSyncEngineLocalServices.js

@@ -1,5 +1,16 @@
 import { applyLocalWorkspaceChanges, applyLocalWorkspaceSyncV3CombinedProjection, applyLocalWorkspaceSyncV3Projection, applyLocalWorkspaceSyncV3TaskCommentAudit, completeLocalSyncAuthoritativeRepair, getLocalWorkspaceContentPullObligations, recordLocalWorkspaceContentPullObligationFailures, getLocalTaskMetadataOwnership, getLocalWorkspaceContentManifest, getLocalWorkspaceSyncV3CombinedProjection, getLocalWorkspaceSyncV3Projection, getLocalWorkspaceSyncV3TaskCommentAudit, } from '../cloudSyncApi.js';
 import { prepareLocalTaskRootOutboxRecovery, } from '../v3/localOutboxRecoveryClient.js';
+export function authoritativeV2ApplyFailureMessage(input) {
+    const data = input.data && typeof input.data === 'object' && !Array.isArray(input.data)
+        ? input.data
+        : {};
+    const detail = String(data.error || '').trim();
+    const code = String(data.code || '').trim();
+    const status = Number(input.status) || 0;
+    return detail
+        ? `Authoritative V2 push echo apply failed (${status}): ${detail}${code ? ` [${code}]` : ''}`
+        : `Authoritative V2 push echo apply failed (${status}).`;
+}
 /**
  * Same-origin HTTP implementation used while the browser owns orchestration.
  */

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;
@@ -83,12 +89,22 @@ export interface WorkspaceSyncEngineRemoteServices {
         workspaceId: string;
         receipts: readonly WorkspaceSyncEngineRemoteTransferReceipt[];
     }): void | Promise<void>;
+    /** Keeps accepted applying receipts alive until a bounded transfer reaches its atomic commit. */
+    retainTransferReceipts?(input: {
+        workspaceId: string;
+        receipts: readonly WorkspaceSyncEngineRemoteTransferReceipt[];
+    }): void | Promise<void>;
     buildV2ApplyCompletionGroup(input: {
         workspaceId: string;
         previousCursor: string | null;
         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/workspaceSyncEngineServerRemoteServices.d.ts

@@ -1,7 +1,7 @@
 import type { LocalSyncExecutionPermitStore } from '../coordinator/localSyncExecutionPermitStore.js';
 import type { WorkspaceSyncTransportGateway } from '../coordinator/workspaceSyncTransportGateway.js';
 import type { WorkspaceSyncEngineRemoteServices } from './workspaceSyncEngineRemoteServices.js';
-type ServerRemotePermitStore = Pick<LocalSyncExecutionPermitStore, 'issueServer' | 'read' | 'acknowledgeNonApplyingCompletion' | 'completeAcceptedPushWithoutEcho' | 'abandonPermit'>;
+type ServerRemotePermitStore = Pick<LocalSyncExecutionPermitStore, 'issueServer' | 'read' | 'acknowledgeNonApplyingCompletion' | 'completeAcceptedPushWithoutEcho' | 'renewAcceptedApplyCompletion' | 'abandonPermit'>;
 type ServerRemoteGateway = Pick<WorkspaceSyncTransportGateway, 'executeServer'>;
 export interface ServerWorkspaceSyncEngineRemoteServicesOptions {
     workspaceId: string;

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.');
@@ -181,6 +202,7 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
             workspaceId: options.workspaceId,
             previousBoundary: input.previousBoundary,
             operationClass,
+            retentionMs: permitDeadlineMs,
         });
         return {
             ...result,
@@ -318,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,
             });
         },
@@ -417,7 +441,25 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
                 }
             }
         },
+        retainTransferReceipts: ({ workspaceId, receipts }) => {
+            const metadata = readReceipts(workspaceId, receipts);
+            const retainedAt = now();
+            for (const receipt of metadata) {
+                options.permitStore.renewAcceptedApplyCompletion({
+                    permitId: receipt.permitId,
+                    workspaceId,
+                    coordinatorGeneration: options.coordinatorGeneration,
+                    ownerMode: 'server',
+                    serverInstanceId: options.serverInstanceId,
+                    deadlineAt: new Date(retainedAt.getTime() + receipt.retentionMs).toISOString(),
+                });
+            }
+        },
         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

@@ -6,6 +6,7 @@ import { runWorkspaceSyncV3CombinedProjectionCycle } from '../v3/workspaceSyncV3
 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;
@@ -146,6 +148,20 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 transformCheckpointAtTransferBoundary: (boundary) => (transferBoundaryCheckpointTransform(boundary)),
             },
         });
+        const prepareAndDrainRecoveryReplay = async (preparedRecovery) => {
+            let recovery = preparedRecovery
+                ?? await localServices.prepareOutboxRecovery(workspaceId);
+            if (recovery.kind === 'recovery' && recovery.state === 'replay_queued') {
+                const drainResult = await options.drainV3Outbox?.({
+                    beforeTransport: () => undefined,
+                });
+                if (drainResult === 'v2-content-push-required') {
+                    fail('v2-content-push', 'A referenced attachment must be published before durable repair can continue.', 'SYNC_RUNNER_V2_CONTENT_PUSH_REQUIRED');
+                }
+                recovery = await localServices.prepareOutboxRecovery(workspaceId);
+            }
+            return recovery;
+        };
         const ensureReady = options.ensureCloudWorkspaceReadyForSync
             || (async () => {
                 const result = await options.remoteServices.handshakeWorkspace(workspaceId);
@@ -499,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) {
@@ -537,11 +555,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,
@@ -569,13 +589,14 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                             ],
                         },
                     });
+                    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,
@@ -583,19 +604,25 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                                 ...acknowledgedOperationIdentities,
                             ],
                         },
-                    });
+                    };
+                    if (acknowledgedOperationIdentities.length
+                        - persistedAcknowledgementCount
+                        >= NON_APPLYING_ACKNOWLEDGEMENT_CHECKPOINT_INTERVAL) {
+                        persist(checkpoint);
+                        persistedAcknowledgementCount = acknowledgedOperationIdentities.length;
+                    }
                 },
             });
             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)) {
@@ -678,6 +705,8 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                             ? { durableRevision: entry.durableRevision }
                             : {}),
                     })), {
+                        repairMode: attemptOptions.repairMode,
+                        excludedProjections: result.effectiveV2ExcludedProjections,
                         ...(completionGroup ? { completionGroup } : {}),
                         commitServerCheckpoint: () => {
                             const persisted = input.persistCheckpoint(nextCheckpoint, {
@@ -697,7 +726,9 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 }
                 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');
+                    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) {
@@ -884,8 +915,7 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 }
                 if (localRecovery.kind === 'recovery'
                     && localRecovery.state === 'replay_queued') {
-                    await options.drainV3Outbox?.({ beforeTransport: () => undefined });
-                    localRecovery = await localServices.prepareOutboxRecovery(workspaceId);
+                    localRecovery = await prepareAndDrainRecoveryReplay(localRecovery);
                 }
                 if (localRecovery.kind === 'recovery'
                     && localRecovery.state === 'replay_queued') {
@@ -912,7 +942,10 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 const continuationInvalid = continuation !== null && (continuation.coordinatorGeneration !== input.coordinatorGeneration
                     || continuation.ownershipFingerprint !== ownershipFingerprint
                     || (recoveryBatchId !== null
-                        && continuation.recoveryBatchId !== recoveryBatchId));
+                        && continuation.recoveryBatchId !== recoveryBatchId)
+                    || (recoveryBatchId !== null
+                        && continuation.kind !== 'v3-combined'
+                        && continuation.kind !== 'v2-reconcile'));
                 if (continuationInvalid || (checkpoint.repairContinuation !== null && !continuation)) {
                     if (checkpoint.pendingV2Push) {
                         await push({
@@ -1030,6 +1063,13 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                     }
                     continuation = checkpoint.repairContinuation;
                 }
+                if (continuation.recoveryBatchId) {
+                    const postPullRecovery = await prepareAndDrainRecoveryReplay();
+                    if (postPullRecovery.kind === 'recovery'
+                        || Number(options.inspectV3Outbox?.().activeDepth || 0) > 0) {
+                        fail('repair', 'Durable recovery replay must settle before authoritative repair continues.', 'SYNC_RUNNER_RECOVERY_REPLAY_PENDING', RETRY_MAX_DELAY_MS);
+                    }
+                }
                 let pushResult = null;
                 if (continuation.kind === 'final-push') {
                     pushResult = await push({