@open-mercato/core 0.6.8-develop.6986.1.3adb0d0df6 → 0.6.8-develop.6992.1.00c90fecff

package/src/modules/customers/components/detail/schedule/LinkedEntitiesField.tsx

@@ -4,6 +4,7 @@ import * as React from 'react'
 import { Building2, Briefcase, FileText, Search, X } from 'lucide-react'
 import { cn } from '@open-mercato/shared/lib/utils'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { hasMoreFromPage } from '@open-mercato/shared/lib/pagination/load-more'
 import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { IconButton } from '@open-mercato/ui/primitives/icon-button'
@@ -14,6 +15,8 @@ import type { LinkedEntity } from './useScheduleFormState'
 
 const ENTITY_LINK_TYPES = ['company', 'deal', 'offer'] as const
 
+const PAGE_SIZE = 20
+
 function readLabelCandidate(value: unknown): string | null {
   if (typeof value !== 'string') return null
   const trimmed = value.trim()
@@ -78,7 +81,10 @@ function EntityLinkSearchPopover({
   const [query, setQuery] = React.useState('')
   const [results, setResults] = React.useState<Array<{ id: string; label: string }>>([])
   const [page, setPage] = React.useState(1)
-  const [totalPages, setTotalPages] = React.useState(1)
+  // Short-page termination instead of a `total`/`totalPages` bound — see
+  // `hasMoreFromPage`. `items` is the raw response, before the mapping and
+  // filtering below, so its length is what the server served.
+  const [hasMore, setHasMore] = React.useState(false)
   const [loading, setLoading] = React.useState(false)
   const selectableResults = React.useMemo(
     () => results.filter((result) => !existingIds.has(result.id)),
@@ -90,12 +96,12 @@ function EntityLinkSearchPopover({
     const controller = new AbortController()
     setLoading(true)
     const searchParam = query.trim() ? `&search=${encodeURIComponent(query.trim())}` : ''
-    const pagingParam = `&page=${page}&pageSize=20`
+    const pagingParam = `&page=${page}&pageSize=${PAGE_SIZE}`
     const endpoint = linkType === 'company'
       ? `/api/customers/companies?sortField=name&sortDir=asc${pagingParam}${searchParam}`
       : linkType === 'deal'
-        ? `/api/customers/deals?pageSize=20&page=${page}${searchParam}`
-        : `/api/sales/quotes?pageSize=20&page=${page}${searchParam}`
+        ? `/api/customers/deals?pageSize=${PAGE_SIZE}&page=${page}${searchParam}`
+        : `/api/sales/quotes?pageSize=${PAGE_SIZE}&page=${page}${searchParam}`
     readApiResultOrThrow<{ items?: Array<Record<string, unknown>>; totalPages?: number; page?: number; pageSize?: number; total?: number }>(endpoint, { signal: controller.signal })
       .then((data) => {
         const items = Array.isArray(data?.items) ? data.items : []
@@ -109,15 +115,12 @@ function EntityLinkSearchPopover({
           nextResults.forEach((entry) => merged.set(entry.id, entry))
           return Array.from(merged.values())
         })
-        if (typeof data?.totalPages === 'number') {
-          setTotalPages(data.totalPages)
-        } else if (typeof data?.total === 'number' && typeof data?.pageSize === 'number') {
-          setTotalPages(Math.max(1, Math.ceil(data.total / data.pageSize)))
-        } else {
-          setTotalPages(1)
-        }
+        setHasMore(hasMoreFromPage(items.length, PAGE_SIZE))
+      })
+      .catch(() => {
+        setResults([])
+        setHasMore(false)
       })
-      .catch(() => setResults([]))
       .finally(() => setLoading(false))
     return () => controller.abort()
   }, [open, page, query, linkType])
@@ -212,7 +215,7 @@ function EntityLinkSearchPopover({
               </Button>
             )
           })}
-          {!loading && page < totalPages ? (
+          {!loading && hasMore ? (
             <div className="px-2 py-2">
               <Button type="button" variant="outline" size="sm" className="w-full" onClick={() => setPage((current) => current + 1)}>
                 {t('customers.schedule.loadMore', 'Load more')}

package/src/modules/customers/components/detail/schedule/ParticipantsField.tsx

@@ -4,6 +4,7 @@ import * as React from 'react'
 import { Users, X, Clock, CheckCircle2, XCircle } from 'lucide-react'
 import { cn } from '@open-mercato/shared/lib/utils'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { hasMoreFromPage } from '@open-mercato/shared/lib/pagination/load-more'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { Checkbox } from '@open-mercato/ui/primitives/checkbox'
 import { IconButton } from '@open-mercato/ui/primitives/icon-button'
@@ -15,6 +16,8 @@ import { isVisible, getFieldLabel } from './fieldConfig'
 import type { Participant, RsvpStatus } from './useScheduleFormState'
 import { PARTICIPANT_COLORS } from './useScheduleFormState'
 
+const PAGE_SIZE = 20
+
 function ParticipantSearchPopover({
   existingIds,
   onAdd,
@@ -30,7 +33,10 @@ function ParticipantSearchPopover({
   const [query, setQuery] = React.useState('')
   const [results, setResults] = React.useState<Array<{ userId: string; name: string; email: string }>>([])
   const [page, setPage] = React.useState(1)
-  const [totalPages, setTotalPages] = React.useState(1)
+  // Short-page termination instead of a `total`-derived page bound — see
+  // `hasMoreFromPage`. Measured on the served count, not on `members`, which is
+  // deduped by user id.
+  const [hasMore, setHasMore] = React.useState(false)
   const [loading, setLoading] = React.useState(false)
   const [loadError, setLoadError] = React.useState<string | null>(null)
   const selectableResults = React.useMemo(
@@ -42,7 +48,7 @@ function ParticipantSearchPopover({
     if (!open) return
     const controller = new AbortController()
     setLoading(true)
-    fetchAssignableStaffMembersPage(query, { page, pageSize: 20, signal: controller.signal })
+    fetchAssignableStaffMembersPage(query, { page, pageSize: PAGE_SIZE, signal: controller.signal })
       .then((result) => {
         const members = result.items
         const nextResults = members.map((member) => ({
@@ -56,11 +62,12 @@ function ParticipantSearchPopover({
           nextResults.forEach((entry) => merged.set(entry.userId, entry))
           return Array.from(merged.values())
         })
-        setTotalPages(result.total > 0 ? Math.max(1, Math.ceil(result.total / result.pageSize)) : 1)
+        setHasMore(hasMoreFromPage(result.servedCount, PAGE_SIZE))
         setLoadError(null)
       })
       .catch(() => {
         setResults([])
+        setHasMore(false)
         setLoadError(
           t(
             'customers.assignableStaff.loadError',
@@ -148,7 +155,7 @@ function ParticipantSearchPopover({
               </Button>
             )
           })}
-          {!loading && !loadError && page < totalPages ? (
+          {!loading && !loadError && hasMore ? (
             <div className="px-2 py-2">
               <Button type="button" variant="outline" size="sm" className="w-full" onClick={() => setPage((current) => current + 1)}>
                 {t('customers.schedule.loadMore', 'Load more')}

package/src/modules/data_sync/AGENTS.md

@@ -104,6 +104,7 @@ interface DataSyncAdapter {
   streamExport?(entityType: string, cursor: string | null, config: SyncConfig): AsyncIterable<ExportBatch>
   getInitialCursor?(entityType: string): Promise<string | null>
   getMapping?(entityType: string): Promise<FieldMapping[]>
+  persistsSharedCursor?(entityType: string): boolean
   validateConnection?(credentials: Record<string, unknown>): Promise<{ valid: boolean; message?: string }>
 }
 ```
@@ -124,7 +125,9 @@ If the sync provider needs bootstrap credentials, mappings, locales, channels, o
 
 `pending` → `running` → `completed` | `failed` | `cancelled`
 
-- **Cursor persistence**: After each batch, cursor is saved to `SyncCursor`
+- **Cursor persistence**: After each batch, the cursor is saved on the run row and mirrored into the shared `SyncCursor` row
+- **Shared cursor opt-out**: An adapter returning `persistsSharedCursor(entityType) === false` keeps that entity type's cursor on the run row only — use it for whole-table backfills whose cursor is one run's scan state, not a durable log position. Those entity types resolve an incremental start position from the most recent run (`resolveResumeCursor`) instead of the shared row, and from `null` when that run completed
+- **Resetting an opt-out**: A reset flow that deletes the shared `SyncCursor` row MUST also call `syncRunService.resetResumePosition(integrationId, entityType, direction, scope)`. An opted-out entity type has no shared row to delete, so deleting only that leaves the resume position on the last interrupted run and the next incremental run re-imports just the tail of the walk it was reset against. The call is a no-op when nothing is interrupted, so make it unconditionally
 - **Resume**: Retry reads the last successful cursor, resumes from there
 - **Progress**: Linked to `ProgressJob` via `progressJobId` for `ProgressTopBar` display
 - **Cancellation**: Via `progressService.isCancellationRequested()`
@@ -172,6 +175,8 @@ Data sync providers can leverage the **Unified Module Extension System (UMES)**
 
 - `ProgressTopBar` and sync-run detail pages use `progress.job.*` SSE updates for live progress.
 - Create `ProgressJob` in `run`/`retry` endpoints; start/update/complete/fail in `sync-engine`.
+- The engine heartbeats (`touchJobHeartbeat`, forked-EM) on a timer while an adapter batch is being produced, because batches can outlast the 60s stale-job sweep — keep the `withHeartbeat` wrapper around `streamImport`/`streamExport` when touching the batch loops.
+- On redelivery the progress counter is seeded from the progress job's own `processedCount` (`progressService.getJob`), mirroring how `committedBatches` resumes — never reset it to zero (`updateProgress` writes absolute counts) and never seed it from the run's `created/updated/skipped/failed` columns: those count emitted items, while progress counts source records (`batch.processedCount`), and adapters may emit several items per source record.
 - Include `progressJob` details in run detail response.
 - SSE DOM bridge forwards only events with `clientBroadcast: true`.
 - `progress.job.*` events are marked `clientBroadcast: true` and must reach the browser from both web and worker processes.

package/src/modules/data_sync/api/run.ts

@@ -10,6 +10,7 @@ import type { SyncRunService } from '../lib/sync-run-service'
 import { runSyncSchema } from '../data/validators'
 import { startDataSyncRun } from '../lib/start-run'
 import { getDataSyncAdapter } from '../lib/adapter-registry'
+import { resolveStartCursor } from '../lib/start-cursor'
 import {
   runCrudMutationGuardAfterSuccess,
   validateCrudMutationGuard,
@@ -109,7 +110,14 @@ export async function POST(req: Request) {
 
     const cursor = parsed.data.fullSync
       ? null
-      : await syncRunService.resolveCursor(parsed.data.integrationId, parsed.data.entityType, parsed.data.direction, scope)
+      : await resolveStartCursor({
+        syncRunService,
+        adapter,
+        integrationId: parsed.data.integrationId,
+        entityType: parsed.data.entityType,
+        direction: parsed.data.direction,
+        scope,
+      })
 
     const { run, progressJob } = await startDataSyncRun({
       syncRunService,

package/src/modules/data_sync/api/runs/[id]/retry.ts

@@ -8,6 +8,7 @@ import type { ProgressService } from '../../../../progress/lib/progressService'
 import type { SyncRunService } from '../../../lib/sync-run-service'
 import { retrySyncSchema } from '../../../data/validators'
 import { startDataSyncRun } from '../../../lib/start-run'
+import { resolveAdapterForIntegration, resolveStartCursor } from '../../../lib/start-cursor'
 import {
   runCrudMutationGuardAfterSuccess,
   validateCrudMutationGuard,
@@ -89,7 +90,14 @@ export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }
 
   const cursor = parsedBody.data.fromBeginning
     ? null
-    : previous.cursor ?? await syncRunService.resolveCursor(previous.integrationId, previous.entityType, previous.direction, scope)
+    : previous.cursor ?? await resolveStartCursor({
+      syncRunService,
+      adapter: resolveAdapterForIntegration(previous.integrationId),
+      integrationId: previous.integrationId,
+      entityType: previous.entityType,
+      direction: previous.direction,
+      scope,
+    })
 
   const { run, progressJob } = await startDataSyncRun({
     syncRunService,

package/src/modules/data_sync/lib/adapter-registry.ts

@@ -1,3 +1,4 @@
+import { getIntegration } from '@open-mercato/shared/modules/integrations/types'
 import type { DataSyncAdapter } from './adapter'
 
 const DATA_SYNC_ADAPTER_REGISTRY_KEY = Symbol.for('@open-mercato/data-sync/adapter-registry')
@@ -25,3 +26,17 @@ export function getDataSyncAdapter(providerKey: string): DataSyncAdapter | undef
 export function getAllDataSyncAdapters(): DataSyncAdapter[] {
   return Array.from(getAdapterRegistry().values())
 }
+
+export function resolveProviderKey(integrationId: string): string {
+  return getIntegration(integrationId)?.providerKey ?? integrationId
+}
+
+/**
+ * The adapter serving an integration. Single source of truth on purpose: the
+ * engine uses it to decide whether to WRITE the shared cursor row and the start
+ * paths use it to decide whether to READ one, and those two decisions must agree
+ * for every integration or an opted-out entity type silently resumes wrong.
+ */
+export function resolveAdapterForIntegration(integrationId: string): DataSyncAdapter | null {
+  return getDataSyncAdapter(resolveProviderKey(integrationId)) ?? null
+}

package/src/modules/data_sync/lib/adapter.ts

@@ -124,6 +124,24 @@ export interface DataSyncAdapter {
    */
   streamImport?(input: StreamImportInput): AsyncIterable<ImportBatch>
   streamExport?(input: StreamExportInput): AsyncIterable<ExportBatch>
+  /**
+   * Whether the engine mirrors this entity type's cursor into the shared
+   * `sync_cursors` row — one row per (integration, entityType, direction,
+   * scope), overwritten by every run that commits a batch.
+   *
+   * Default `true`. Return `false` for an entity type whose cursor is a single
+   * run's scan state rather than a durable position in a log. The run row keeps
+   * `initialCursor` + `cursor` either way, so a redelivered job still resumes
+   * exactly; what goes away is two concurrent or consecutive runs of the same
+   * entity type silently redefining each other's start position.
+   *
+   * The distinction is a blast radius, not a preference: losing a log position
+   * means re-draining the whole change queue, while losing a table walk's
+   * position means re-walking a table the adapter already re-walks idempotently.
+   * The predicate is per entity type because one adapter commonly serves both
+   * kinds — an incremental feed and a whole-table backfill.
+   */
+  persistsSharedCursor?(entityType: string): boolean
   getInitialCursor?(input: { entityType: string; scope: TenantScope }): Promise<string | null>
   getMapping(input: { entityType: string; scope: TenantScope }): Promise<DataMapping>
   validateConnection?(input: {

package/src/modules/data_sync/lib/start-cursor.ts

@@ -0,0 +1,35 @@
+import type { DataSyncAdapter } from './adapter'
+import type { SyncRunService } from './sync-run-service'
+
+type SyncScope = {
+  organizationId: string
+  tenantId: string
+}
+
+export { resolveAdapterForIntegration } from './adapter-registry'
+
+export function persistsSharedCursor(adapter: DataSyncAdapter | null | undefined, entityType: string): boolean {
+  return adapter?.persistsSharedCursor?.(entityType) ?? true
+}
+
+/**
+ * Start position for a non-full run. Entity types that mirror their cursor into
+ * the shared `sync_cursors` row read it from there. Entity types whose adapter
+ * opted out never write that row, so reading it would silently turn every
+ * incremental run into a full one — they resume from their own last run
+ * instead.
+ */
+export async function resolveStartCursor(params: {
+  syncRunService: SyncRunService
+  adapter?: DataSyncAdapter | null
+  integrationId: string
+  entityType: string
+  direction: 'import' | 'export'
+  scope: SyncScope
+}): Promise<string | null> {
+  const { syncRunService, adapter, integrationId, entityType, direction, scope } = params
+  if (persistsSharedCursor(adapter, entityType)) {
+    return syncRunService.resolveCursor(integrationId, entityType, direction, scope)
+  }
+  return syncRunService.resolveResumeCursor(integrationId, entityType, direction, scope)
+}

package/src/modules/data_sync/lib/sync-engine.ts

@@ -4,10 +4,11 @@ import type { CredentialsService } from '../../integrations/lib/credentials-serv
 import type { IntegrationLogService } from '../../integrations/lib/log-service'
 import type { IntegrationStateService } from '../../integrations/lib/state-service'
 import type { ProgressService } from '../../progress/lib/progressService'
+import { STALE_JOB_TIMEOUT_SECONDS } from '../../progress/lib/progressService'
 import { refreshCoverageSnapshot } from '../../query_index/lib/coverage'
 import { emitDataSyncEvent } from '../events'
 import type { DataSyncAdapter, DataMapping, ExportBatch, ImportBatch } from './adapter'
-import { getDataSyncAdapter } from './adapter-registry'
+import { getDataSyncAdapter, resolveProviderKey } from './adapter-registry'
 import type { SyncRunService } from './sync-run-service'
 import { SyncRunOwnershipConflictError } from './sync-run-service'
 import { createLogger } from '@open-mercato/shared/lib/logger'
@@ -29,10 +30,6 @@ type EngineDeps = {
   progressService: ProgressService
 }
 
-function resolveProviderKey(integrationId: string): string {
-  return getIntegration(integrationId)?.providerKey ?? integrationId
-}
-
 function applyImportCounters(batch: ImportBatch): Pick<Required<SyncCounterDelta>, 'createdCount' | 'updatedCount' | 'skippedCount' | 'failedCount'> {
   let createdCount = 0
   let updatedCount = 0
@@ -76,6 +73,32 @@ function applyExportCounters(batch: ExportBatch): SyncCounterDelta {
   }
 }
 
+// Adapter batches can legitimately outlast the stale-job sweep window (slow upstream
+// APIs), so the engine must heartbeat while a batch is still being produced.
+const HEARTBEAT_TICK_MS = (STALE_JOB_TIMEOUT_SECONDS * 1000) / 4
+
+// Runs `tick` on an interval only while the source iterator is pending, so heartbeats
+// stop the moment the producer dies and genuinely stale jobs still get swept. The outer
+// finally closes the adapter generator on early exits (cancellation, ownership conflict).
+async function* withHeartbeat<T>(source: AsyncIterable<T>, tick: () => void, intervalMs: number): AsyncGenerator<T, void, undefined> {
+  const iterator = source[Symbol.asyncIterator]()
+  try {
+    while (true) {
+      const timer = setInterval(tick, intervalMs)
+      let result: IteratorResult<T>
+      try {
+        result = await iterator.next()
+      } finally {
+        clearInterval(timer)
+      }
+      if (result.done) return
+      yield result.value
+    }
+  } finally {
+    await iterator.return?.()
+  }
+}
+
 export function createSyncEngine(deps: EngineDeps) {
   const { syncRunService, integrationCredentialsService, integrationLogService, integrationStateService, progressService } = deps
 
@@ -103,6 +126,47 @@ export function createSyncEngine(deps: EngineDeps) {
     )
   }
 
+  // On redelivery the progress counter must resume where the last delivery left off the
+  // same way committedBatches does — updateProgress writes absolute counts, so starting at
+  // zero would regress the visible count. The progress job's own processedCount is the only
+  // persisted value already in the engine's unit: `batch.processedCount ?? items.length`,
+  // i.e. source records. The run's created/updated/skipped/failed counters count emitted
+  // items, which adapters may explode several-per-source-record (Akeneo yields a product
+  // plus its variants), so seeding from them would overshoot the total and pin the bar.
+  async function seedProcessedCount(progressJobId: string | null | undefined, scope: SyncScope): Promise<number> {
+    if (!progressJobId) return 0
+    const job = await progressService.getJob(progressJobId, {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      userId: scope.userId,
+    })
+    return job?.processedCount ?? 0
+  }
+
+  function makeHeartbeatTick(progressJobId: string | null | undefined, scope: SyncScope): () => void {
+    const touchJobHeartbeat = progressService.touchJobHeartbeat?.bind(progressService)
+    if (!progressJobId || !touchJobHeartbeat) return () => {}
+    let inFlight = false
+    return () => {
+      if (inFlight) return
+      inFlight = true
+      touchJobHeartbeat(progressJobId, {
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+        userId: scope.userId,
+      })
+        .catch((error) => {
+          logger.warn('Progress heartbeat failed', {
+            progressJobId,
+            error: error instanceof Error ? error.message : String(error),
+          })
+        })
+        .finally(() => {
+          inFlight = false
+        })
+    }
+  }
+
   async function refreshCoverageSnapshots(entityTypes: string[] | undefined, scope: SyncScope): Promise<void> {
     if (!entityTypes || entityTypes.length === 0) return
 
@@ -418,6 +482,7 @@ export function createSyncEngine(deps: EngineDeps) {
         throw new Error(`No import adapter registered for provider ${providerKey}`)
       }
       const operationalTelemetry = adapter.operationalTelemetry === true
+      const persistSharedCursor = adapter.persistsSharedCursor?.(run.entityType) ?? true
 
       const credentials = await integrationCredentialsService.resolve(run.integrationId, scope)
       if (!credentials) {
@@ -471,20 +536,24 @@ export function createSyncEngine(deps: EngineDeps) {
       }
 
       const mapping = await resolveMapping(adapter, run.entityType, scope)
-      let processedCount = 0
+      let processedCount = await seedProcessedCount(run.progressJobId, scope)
       let totalCount: number | null = null
       let committedBatches = activeRun.batchesCompleted ?? 0
 
       try {
-        for await (const batch of adapter.streamImport({
-          entityType: run.entityType,
-          cursor: run.cursor ?? undefined,
-          batchSize,
-          credentials,
-          mapping,
-          scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
-          runId: run.id,
-        })) {
+        for await (const batch of withHeartbeat(
+          adapter.streamImport({
+            entityType: run.entityType,
+            cursor: run.cursor ?? undefined,
+            batchSize,
+            credentials,
+            mapping,
+            scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
+            runId: run.id,
+          }),
+          makeHeartbeatTick(run.progressJobId, scope),
+          HEARTBEAT_TICK_MS,
+        )) {
           if (run.progressJobId && await progressService.isCancellationRequested(run.progressJobId, scope.tenantId, scope.organizationId)) {
             await finalizeRun(run.id, 'cancelled', scope, undefined, operationalTelemetry)
             return
@@ -503,7 +572,7 @@ export function createSyncEngine(deps: EngineDeps) {
             },
             batch.cursor,
             scope,
-            committedBatches,
+            { expectedBatchesCompleted: committedBatches, persistSharedCursor },
           )
           committedBatches += 1
 
@@ -578,6 +647,7 @@ export function createSyncEngine(deps: EngineDeps) {
         throw new Error(`No export adapter registered for provider ${providerKey}`)
       }
       const operationalTelemetry = adapter.operationalTelemetry === true
+      const persistSharedCursor = adapter.persistsSharedCursor?.(run.entityType) ?? true
 
       const credentials = await integrationCredentialsService.resolve(run.integrationId, scope)
       if (!credentials) {
@@ -631,19 +701,23 @@ export function createSyncEngine(deps: EngineDeps) {
       }
 
       const mapping = await resolveMapping(adapter, run.entityType, scope)
-      let processedCount = 0
+      let processedCount = await seedProcessedCount(run.progressJobId, scope)
       let committedBatches = activeRun.batchesCompleted ?? 0
 
       try {
-        for await (const batch of adapter.streamExport({
-          entityType: run.entityType,
-          cursor: run.cursor ?? undefined,
-          batchSize,
-          credentials,
-          mapping,
-          scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
-          runId: run.id,
-        })) {
+        for await (const batch of withHeartbeat(
+          adapter.streamExport({
+            entityType: run.entityType,
+            cursor: run.cursor ?? undefined,
+            batchSize,
+            credentials,
+            mapping,
+            scope: { organizationId: scope.organizationId, tenantId: scope.tenantId },
+            runId: run.id,
+          }),
+          makeHeartbeatTick(run.progressJobId, scope),
+          HEARTBEAT_TICK_MS,
+        )) {
           if (run.progressJobId && await progressService.isCancellationRequested(run.progressJobId, scope.tenantId, scope.organizationId)) {
             await finalizeRun(run.id, 'cancelled', scope, undefined, operationalTelemetry)
             return
@@ -663,7 +737,7 @@ export function createSyncEngine(deps: EngineDeps) {
             },
             batch.cursor,
             scope,
-            committedBatches,
+            { expectedBatchesCompleted: committedBatches, persistSharedCursor },
           )
           committedBatches += 1
           await updateProgress(run.progressJobId, processedCount, null, scope)