@open-mercato/core 0.8.1-develop.7296.1.2111d779db → 0.8.1-develop.7441.1.b42958b98c

package/src/modules/dashboards/api/widgets/data/route.ts

@@ -4,6 +4,7 @@ import type { CacheStrategy } from '@open-mercato/cache'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { resolveOrganizationScopeFilter } from '@open-mercato/core/modules/directory/utils/organizationScopeFilter'
 import {
   createWidgetDataService,
   type WidgetDataRequest,
@@ -49,6 +50,14 @@ export async function POST(req: Request) {
   const container = await createRequestContainer()
   const analyticsRegistry = container.resolve<AnalyticsRegistry>('analyticsRegistry')
 
+  const tenantId = auth.tenantId ?? null
+  if (!tenantId) {
+    return NextResponse.json({ error: 'Tenant context is required' }, { status: 400 })
+  }
+
+  const scope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
+  const { organizationIds, rbacOrganizationId } = resolveOrganizationScopeFilter(scope, auth)
+
   const entityFeatures = analyticsRegistry.getRequiredFeatures(parsed.data.entityType)
   if (entityFeatures && entityFeatures.length > 0) {
     const rbacService = container.resolve<{
@@ -59,8 +68,8 @@ export async function POST(req: Request) {
       ) => Promise<boolean>
     }>('rbacService')
     const hasAccess = await rbacService.userHasAllFeatures(auth.sub, entityFeatures, {
-      tenantId: auth.tenantId!,
-      organizationId: auth.orgId,
+      tenantId,
+      organizationId: rbacOrganizationId,
     })
     if (!hasAccess) {
       return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
@@ -73,21 +82,6 @@ export async function POST(req: Request) {
     useContext: true,
   })
 
-  const tenantId = auth.tenantId ?? null
-  if (!tenantId) {
-    return NextResponse.json({ error: 'Tenant context is required' }, { status: 400 })
-  }
-
-  const scope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
-
-  const organizationIds = (() => {
-    if (scope?.selectedId) return [scope.selectedId]
-    if (Array.isArray(scope?.filterIds) && scope.filterIds.length > 0) return scope.filterIds
-    if (scope?.allowedIds === null) return undefined
-    if (auth.orgId) return [auth.orgId]
-    return undefined
-  })()
-
   const userFeatures = Array.isArray(auth.features)
     ? auth.features.filter((value): value is string => typeof value === 'string')
     : []
@@ -111,7 +105,7 @@ export async function POST(req: Request) {
       container,
       userId: auth.sub ?? '',
       tenantId,
-      organizationId: organizationIds?.[0] ?? auth.orgId ?? '',
+      organizationId: rbacOrganizationId ?? '',
       userFeatures,
     },
   })

package/src/modules/dashboards/lib/aggregations.ts

@@ -198,7 +198,7 @@ function buildWhereClause(
   whereClauses.push(`tenant_id = ?`)
   params.push(options.scope.tenantId)
 
-  if (options.scope.organizationIds && options.scope.organizationIds.length > 0) {
+  if (options.scope.organizationIds !== undefined) {
     whereClauses.push(`organization_id = ANY(?::uuid[])`)
     params.push(`{${options.scope.organizationIds.join(',')}}`)
   }

package/src/modules/dashboards/lib/widgetScope.ts

@@ -4,6 +4,7 @@ import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { isUnrestrictedOrganizationScope } from '@open-mercato/shared/lib/auth/organizationAccess'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { resolveOrganizationScopeFilter } from '@open-mercato/core/modules/directory/utils/organizationScopeFilter'
 
 export type WidgetScopeContext = {
   container: AppContainer
@@ -74,13 +75,7 @@ export async function resolveWidgetScope(
     throw forbiddenScope()
   }
 
-  const organizationIds = (() => {
-    if (scope?.selectedId) return [scope.selectedId]
-    if (Array.isArray(scope?.filterIds) && scope.filterIds.length > 0) return scope.filterIds
-    if (scope?.allowedIds === null) return null
-    if (auth.orgId) return [auth.orgId]
-    return [] as string[]
-  })()
+  const organizationIds = resolveOrganizationScopeFilter(scope, auth).organizationIds ?? null
 
   if (organizationIds !== null && organizationIds.length === 0) {
     throw new CrudHttpError(400, { error: translate('dashboards.errors.organization_required', 'Organization context is required') })

package/src/modules/data_sync/AGENTS.md

@@ -56,6 +56,7 @@ packages/core/src/modules/data_sync/
 │   ├── queue.ts                 # Queue helper for enqueuing sync jobs
 │   ├── batch-stream.ts          # Drives adapter streams; one root span per batch
 │   ├── run-parameters.ts        # Validate/coerce operator run parameters vs. adapter declaration
+│   ├── resume-point.ts          # What a retry of a run would do — shared by list + detail
 │   ├── sync-engine.ts           # Orchestrates streaming import/export with progress
 │   └── sync-run-service.ts      # CRUD for SyncRun + cursor management
 ├── api/
@@ -112,6 +113,10 @@ interface DataSyncAdapter {
   getMapping(input: { entityType: string; scope: TenantScope }): Promise<DataMapping>
   persistsSharedCursor?(entityType: string): boolean
   supportsStartControl?(control: 'fullSync' | 'batchSize', entityType: string): boolean
+  describeProgressJob?(input: {
+    entityType: string
+    direction: 'import' | 'export'
+  }): DataSyncProgressJobDescription | undefined
   validateConnection?(input: {
     entityType: string
     credentials: Record<string, unknown>
@@ -162,6 +167,10 @@ Run parameters are **operator-visible and stored in clear text** on
 declare a parameter that carries a secret — credentials belong in
 `integrationCredentialsService`.
 
+A **cursor is operator-visible too** — `cursor` and `initialCursor` are rendered
+verbatim on the dashboard and invited into support tickets — so never encode a
+credential or personal data in one either.
+
 **Translation.** `label`, `description` and `placeholder` are literals, so an
 adapter shipping to more than one locale MUST also set `labelKey` /
 `descriptionKey` / `placeholderKey`; the dashboard prefers the key and falls
@@ -224,6 +233,31 @@ Do not derive applicability from `persistsSharedCursor` — where a cursor is
 stored and whether restarting from scratch is meaningful are independent facts,
 and both belong to the adapter to state.
 
+### Progress job description
+
+Unless the caller passes `createProgressJob: false`, every run started through
+`startDataSyncRun` (`lib/start-run.ts`) — the run route, Retry, the scheduled
+worker and provider-owned routes — creates a `ProgressJob` that `ProgressTopBar`
+shows to every user with `progress.view`, with Cancel for anyone holding
+`progress.cancel`. An adapter may describe that
+job per entity type:
+
+```typescript
+describeProgressJob: ({ entityType }) =>
+  entityType === 'orders.feed' ? { meta: { hiddenFromTopBar: true } } : undefined,
+```
+
+Use it for an entity type whose run is long-lived — a continuously running feed
+never reaches 100%, so without it the top bar reads as running forever and
+offers a Cancel that stops the feed. `name`, `description` and `meta` merge as
+core default < adapter < the caller's own `progressJob` (meta key by key), so a
+provider route that passes `progressJob.meta` still wins. The run's identity
+keys in `meta` — `integrationId`, `entityType`, `direction` — are not the
+adapter's to overwrite. The hook is not
+consulted when the caller passes `createProgressJob: false`, and an answer that
+throws or has the wrong shape is ignored with a warning — an adapter cannot make
+itself unstartable over how its progress job reads.
+
 If the sync provider needs bootstrap credentials, mappings, locales, channels, or other default sync settings after a fresh install, implement a provider-owned env preset flow:
 
 - read env vars in the provider package
@@ -238,7 +272,7 @@ If the sync provider needs bootstrap credentials, mappings, locales, channels, o
 - **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
+- **Retry / Resume / Run again**: three operator actions over two endpoints. **Retry** (`failed`) and **Resume** (`cancelled`) are the same request — `runs/[id]/retry` with `fromBeginning: false` — resuming from the run's committed `cursor`, or from `resolveStartCursor(...)` when it committed none. **Retry from the beginning** sends `fromBeginning: true` for a `null` start cursor; it is UI-gated on `supportsStartControl('fullSync', entityType)` while the endpoint keeps accepting the field. **Run again** (`completed`) opens the prefilled start form at `/backend/data-sync?from=<runId>` and posts `data_sync/run`. `lib/resume-point.ts` (`resolveResumePoint`) turns a run row into the one sentence both surfaces render, and never claims a start position for a run that committed no batch
 - **Progress**: Linked to `ProgressJob` via `progressJobId` for `ProgressTopBar` display
 - **Cancellation**: The engine polls `progressService.isCancellationRequested()` in the batch handler AND on the heartbeat tick while a batch is still in flight, aborting `StreamImportInput.signal` / `StreamExportInput.signal`. Adapters SHOULD honour the signal wherever the work is divisible (per page, per record, around a long flush) and `return` — with the `return` ABOVE the `yield`, never below it, or the engine commits a cursor for a half-applied page. Adapters that ignore the signal keep the old between-batches behavior.
 - **Error reporting**: Every `level: 'error'` row the engine writes is also reported to the active telemetry backend, grouped by a `code`. A `failed` import item MAY carry `data.errorCode` (a stable `module.reason` token, never an interpolated string) alongside `data.errorMessage`; the engine ENFORCES that shape — it is a metric label, so an interpolated value would blow up cardinality and, unlike attributes, would egress unredacted — and substitutes `data_sync.item_failed` for anything else, including a missing value. A run that finishes with `failedCount > 0` additionally reports one `data_sync.run_partial_failure` summary, independent of `adapter.operationalTelemetry` — that flag decides how chatty the operational log is, never whether a failure is observable. Policy: [`error-reporting.mdx`](../../../../../apps/docs/docs/framework/runtime/error-reporting.mdx)

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

@@ -78,6 +78,11 @@ export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }
     userId: auth.sub,
   }
 
+  const cancelledRun = await syncRunService.markStatus(run.id, 'cancelled', scope)
+  if (cancelledRun?.status !== 'cancelled') {
+    return NextResponse.json({ error: 'Only pending or running runs can be cancelled' }, { status: 409 })
+  }
+
   if (run.progressJobId) {
     try {
       await progressService.markCancelled(run.progressJobId, progressCtx)
@@ -93,7 +98,6 @@ export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }
     }
   }
 
-  await syncRunService.markStatus(run.id, 'cancelled', scope)
   await integrationStateService.upsert(run.integrationId, {
     lastHealthStatus: 'degraded',
     lastHealthCheckedAt: new Date(),

package/src/modules/data_sync/backend/data-sync/page.tsx

@@ -2,7 +2,7 @@
 import * as React from 'react'
 import { extensionPoints } from '@open-mercato/core/modules/data_sync/extension-points'
 import Link from 'next/link'
-import { useRouter } from 'next/navigation'
+import { useRouter, useSearchParams } from 'next/navigation'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { DataTable } from '@open-mercato/ui/backend/DataTable'
 import type { LegacyColumnDef as ColumnDef } from '@tanstack/react-table/legacy'
@@ -47,6 +47,9 @@ import {
   ShieldCheck,
 } from 'lucide-react'
 import { getSyncRunStatusVariant, getSyncSummaryVariant } from '../../lib/syncRunStatus'
+import { isRetryableRunStatus } from '../../lib/resume-point'
+import { useDataSyncRunAccess } from '../../components/useDataSyncRunAccess'
+import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import type { RunParameter } from '../../lib/adapter'
 import { getApplicableRunParameters } from '../../lib/run-parameters'
 import {
@@ -65,6 +68,14 @@ import {
   type RunParameterFormValue,
 } from '../../components/RunParameterFields'
 
+function fromBeginningLabel(status: string, t: (key: string, fallback: string) => string): string {
+  // A cancelled run avoids the word "Retry" on its primary action; letting it
+  // back in through the overflow would undo that.
+  return status === 'cancelled'
+    ? t('data_sync.runs.detail.retryFromBeginning.actionCancelled', 'Start from the beginning')
+    : t('data_sync.runs.detail.retryFromBeginning.action', 'Retry from the beginning')
+}
+
 type SyncRunRow = {
   id: string
   integrationId: string
@@ -207,6 +218,48 @@ export default function SyncRunsDashboardPage() {
   const [isDeletingSchedule, setIsDeletingSchedule] = React.useState(false)
   const [scheduleValueError, setScheduleValueError] = React.useState<ScheduleValueError>(null)
   const [reloadToken, setReloadToken] = React.useState(0)
+  // Server-side the run endpoints already require `data_sync.run`; the pages
+  // did not, so a `data_sync.view` holder saw buttons that 403 on click.
+  const { canRunSync, canConfigureSync } = useDataSyncRunAccess()
+  const { confirm, ConfirmDialogElement } = useConfirmDialog()
+  const searchParams = useSearchParams()
+  const fromRunId = searchParams?.get('from') ?? null
+  /**
+   * The seed is applied eagerly AND left for the two pre-existing reset effects
+   * to honour, because neither mechanism is sufficient alone: those effects do
+   * not re-run when the seeded integration is already the selected one, and
+   * eager writes alone would be clobbered when they do run.
+   *
+   * Each effect consumes the seed at most once, tracked per token, so a later
+   * manual change falls through to the ordinary defaults instead of having the
+   * old run's values re-applied over it.
+   */
+  const seedRef = React.useRef<{
+    token: string
+    entityType: string
+    direction: 'import' | 'export'
+    parameters: Record<string, unknown>
+  } | null>(null)
+  const seedConsumedRef = React.useRef<{ selection: string | null; parameters: string | null }>({ selection: null, parameters: null })
+  const seedAttemptedRef = React.useRef<string | null>(null)
+  const seedMountedRef = React.useRef(true)
+  const seedSequenceRef = React.useRef(0)
+  /**
+   * State, not a ref, so a new seed re-runs the parameter effect on its own.
+   * That effect is otherwise keyed on the `runParameters` memo, whose identity
+   * does not change when the seeded run uses the integration, entity type and
+   * direction the form already carries — the dashboard row menu's common case.
+   * It is never cleared: clearing it would re-run the effect with no seed and
+   * reset the operator's own edits to the defaults.
+   */
+  const [seedToken, setSeedToken] = React.useState<string | null>(null)
+
+  /** An operator touching the form retires the seed — and the banner with it. */
+  const retireSeed = React.useCallback(() => {
+    seedRef.current = null
+    setSeedSource(null)
+  }, [])
+  const [seedSource, setSeedSource] = React.useState<{ integrationId: string; entityType: string; droppedKeys: string[] } | null>(null)
   const scopeVersion = useOrganizationScopeVersion()
   const t = useT()
   const { runMutation } = useGuardedMutation<Record<string, unknown>>({
@@ -306,8 +359,25 @@ export default function SyncRunsDashboardPage() {
   )
 
   React.useEffect(() => {
-    setParamValues(buildDefaultRunParameterValues(runParameters))
-  }, [runParameters])
+    const defaults = buildDefaultRunParameterValues(runParameters)
+    const seed = seedRef.current
+    if (!seed || seedConsumedRef.current.parameters === seed.token) {
+      setParamValues(defaults)
+      return
+    }
+    seedConsumedRef.current.parameters = seed.token
+    const seeded: Record<string, RunParameterFormValue> = { ...defaults }
+    for (const param of runParameters) {
+      const raw = seed.parameters[param.key]
+      if (raw === undefined || raw === null) continue
+      // The API returns each parameter with its coerced type, so a number
+      // arrives as a JS number and the text input would render blank while
+      // `buildRunParametersPayload` still shipped it. `RunParameterFormValue`
+      // is `string | boolean`; normalise the way the defaults builder does.
+      seeded[param.key] = param.type === 'boolean' ? raw === true : String(raw)
+    }
+    setParamValues(seeded)
+  }, [runParameters, seedToken])
 
   // A control the form stopped showing must not keep submitting the value the
   // operator last set for another entity type.
@@ -328,6 +398,17 @@ export default function SyncRunsDashboardPage() {
       setSelectedEntityType('')
       return
     }
+    const seed = seedRef.current
+    if (
+      seed
+      && seedConsumedRef.current.selection !== seed.token
+      && selectedIntegration.supportedEntities.includes(seed.entityType)
+    ) {
+      seedConsumedRef.current.selection = seed.token
+      setSelectedEntityType(seed.entityType)
+      setSelectedDirection(seed.direction)
+      return
+    }
     setSelectedEntityType((current) => (
       current && selectedIntegration.supportedEntities.includes(current)
         ? current
@@ -431,6 +512,164 @@ export default function SyncRunsDashboardPage() {
     }
   }, [t])
 
+  /**
+   * Seeds the start form from `?from=<runId>`, exactly once, after the options
+   * response has resolved — the integration list must exist before an
+   * integration can be selected.
+   *
+   * Only what `sync_runs` actually stores is copied: integration, entity type,
+   * direction and the stored parameters. `fullSync` and batch size are NOT
+   * seeded, because the table has no column for either — they are consumed when
+   * a run starts and thrown away.
+   */
+  React.useEffect(() => {
+    // `router.replace` below drops the parameter, so a second "Run again" on the
+    // same run arrives as null → id. Re-arming on the null is what lets that
+    // repeat work without the guard also re-firing on every effect re-run.
+    if (!fromRunId) {
+      seedAttemptedRef.current = null
+      return
+    }
+    if (isLoadingOptions) return
+    if (seedAttemptedRef.current === fromRunId) return
+    seedAttemptedRef.current = fromRunId
+
+    const seed = async () => {
+      const call = await apiCall<{
+        integrationId: string
+        entityType: string
+        direction: 'import' | 'export'
+        parameters: Record<string, unknown> | null
+      }>(`/api/data_sync/runs/${encodeURIComponent(fromRunId)}`, undefined, { fallback: null })
+
+      // Only an unmount aborts this: an earlier version cancelled on every effect
+      // re-run, which — with the ref guard blocking a second fetch — meant the
+      // seed never landed at all. An unknown, malformed or cross-tenant id is
+      // not an error state either; the form renders its normal defaults, and the
+      // attempt stays recorded so this cannot retry in a loop.
+      if (!seedMountedRef.current || !call.ok || !call.result) return
+      // A second "Run again" re-points `seedAttemptedRef` while this fetch is in
+      // flight; the page stays mounted across that query-only navigation, so a
+      // slower first response must not overwrite the seed the second one applied.
+      if (seedAttemptedRef.current !== fromRunId) return
+
+      const source = call.result
+      const integration = options.find((option) => option.integrationId === source.integrationId)
+      // Validated once here so both seeding paths agree: the same-integration
+      // path never re-runs the selection effect, so nothing would catch an
+      // entity type the adapter has since dropped. Seeding one anyway leaves
+      // Start sync enabled against a value the API answers 422 to, while the
+      // banner claims everything was copied.
+      if (!integration || !integration.supportedEntities.includes(source.entityType)) return
+
+      // The shared resolver, so the banner and the form cannot disagree: it also
+      // honours `entityType` scoping, which a direction-only filter missed — a
+      // re-scoped parameter was counted as carried, then silently dropped.
+      const declaredKeys = new Set(
+        getApplicableRunParameters(integration.runParameters, source.direction, source.entityType)
+          .map((param) => param.key),
+      )
+      const stored = source.parameters ?? {}
+      const carried: Record<string, unknown> = {}
+      const dropped: string[] = []
+      for (const [key, value] of Object.entries(stored)) {
+        if (declaredKeys.has(key)) carried[key] = value
+        else dropped.push(key)
+      }
+
+      // A counter, not a timestamp: two "Run again" clicks on the same run
+      // inside one millisecond would otherwise mint the same token, and the
+      // parameter effect — keyed on it — would not re-run for the second.
+      seedSequenceRef.current += 1
+      const token = `${fromRunId}:${seedSequenceRef.current}`
+      seedRef.current = {
+        token,
+        entityType: source.entityType,
+        direction: source.direction,
+        parameters: carried,
+      }
+      seedConsumedRef.current = { selection: null, parameters: null }
+
+      // Applied eagerly as well as left for the effects: selecting an
+      // integration that is already selected re-runs neither of them, and that
+      // is the common case when "Run again" is clicked from the dashboard.
+      setSelectedIntegrationId(source.integrationId)
+      setSelectedEntityType(source.entityType)
+      setSelectedDirection(source.direction)
+      setSeedSource({ integrationId: source.integrationId, entityType: source.entityType, droppedKeys: dropped })
+      setSeedToken(token)
+
+      // Drop the parameter so a re-render or a back-navigation cannot re-seed
+      // over edits the operator has since made.
+      router.replace('/backend/data-sync')
+    }
+    void seed()
+  }, [fromRunId, isLoadingOptions, options, router])
+
+  React.useEffect(() => {
+    seedMountedRef.current = true
+    return () => { seedMountedRef.current = false }
+  }, [])
+
+  const handleRetryFromBeginning = React.useCallback(async (row: SyncRunRow) => {
+    const confirmed = await confirm({
+      title: t('data_sync.runs.detail.retryFromBeginning.title', 'Retry from the beginning?'),
+      text: [
+        t('data_sync.runs.detail.retryFromBeginning.confirm', 'This ignores the saved cursor and reads the entire source again, instead of continuing.'),
+        t('data_sync.runs.detail.retryFromBeginning.confirmMatched', 'Existing records are matched and updated, not duplicated.'),
+      ].join(' '),
+      confirmText: t('data_sync.runs.detail.retryFromBeginning.action', 'Retry from the beginning'),
+      variant: 'default',
+    })
+    if (!confirmed) return
+    const call = await runMutation({
+      // optimistic-lock-exempt: starts a new retry run (create), not a concurrent record edit
+      operation: () => apiCall(`/api/data_sync/runs/${encodeURIComponent(row.id)}/retry`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fromBeginning: true }),
+      }, { fallback: null }),
+      mutationPayload: { runId: row.id, fromBeginning: true },
+      context: { operation: 'create', actionId: 'retry-sync-run-from-beginning', runId: row.id },
+    })
+    if (call.ok) {
+      flash(t('data_sync.runs.detail.retrySuccess'), 'success')
+      setReloadToken((token) => token + 1)
+    } else {
+      flash(buildRetryFailureMessage(call.result as RetryFailureBody | null, t), 'error')
+    }
+  }, [confirm, runMutation, t])
+
+  /**
+   * `RowActionItem.label` is rendered as the sole child of a fixed-width,
+   * `whitespace-nowrap` button, so a label carrying the resume point overflows
+   * the menu box. The resume point therefore lives only on the run detail page,
+   * which has room to state it in full.
+   */
+  const buildRetryActions = React.useCallback((row: SyncRunRow) => {
+    if (!canRunSync) return []
+    if (!isRetryableRunStatus(row.status)) return []
+    const actions = [{
+      id: 'retry',
+      label: row.status === 'cancelled'
+        ? t('data_sync.dashboard.actions.resume', 'Resume')
+        : t('data_sync.runs.detail.retry', 'Retry'),
+      onSelect: () => { void handleRetry(row) },
+    }]
+    // Same adapter gating as the detail page, and the same fail-open default.
+    // No explanatory footnote here: a row menu lists actions, it does not
+    // explain an absent one — the detail page carries that sentence.
+    const integration = options.find((option) => option.integrationId === row.integrationId)
+    if (applicableStartControls(integration?.startControls, row.entityType).fullSync) {
+      actions.push({
+        id: 'retry-from-beginning',
+        label: fromBeginningLabel(row.status, t),
+        onSelect: () => { void handleRetryFromBeginning(row) },
+      })
+    }
+    return actions
+  }, [canRunSync, handleRetry, handleRetryFromBeginning, options, t])
+
   const handleFiltersApply = React.useCallback((values: FilterValues) => {
     const next: FilterValues = {}
     Object.entries(values).forEach(([key, value]) => {
@@ -704,13 +943,17 @@ export default function SyncRunsDashboardPage() {
   ], [t])
 
   const canStartSelectedIntegration = Boolean(
-    selectedIntegration
+    canRunSync
+    && selectedIntegration
     && selectedEntityType
     && selectedIntegration.isEnabled
     && selectedIntegration.canStartRun !== false
     && selectedIntegration.hasCredentials,
   )
   const hasSavedSchedule = Boolean(scheduleEditor.id)
+  // One expression for all seven schedule controls: the duplication is what let
+  // the two buttons drift out of the feature gate.
+  const scheduleControlsDisabled = !canConfigureSync || isLoadingSchedule || isSavingSchedule || isDeletingSchedule
   const selectedEntityLabel = selectedEntityType ? formatEntityTypeLabel(selectedEntityType) : t('data_sync.dashboard.columns.entityType')
   const integrationStateVariant = getSyncSummaryVariant(selectedIntegration?.isEnabled ? 'enabled' : 'disabled')
   const credentialsVariant = getSyncSummaryVariant(selectedIntegration?.hasCredentials ? 'ready' : 'missing')
@@ -722,6 +965,7 @@ export default function SyncRunsDashboardPage() {
 
   return (
     <Page>
+      {ConfirmDialogElement}
       <PageBody className="space-y-6">
         <Card>
           <CardHeader className="space-y-4">
@@ -782,6 +1026,31 @@ export default function SyncRunsDashboardPage() {
             ) : null}
           </CardHeader>
           <CardContent className="space-y-6">
+            {seedSource ? (
+              <Alert status="information">
+                <AlertDescription className="space-y-1">
+                  <p>
+                    {t('data_sync.dashboard.start.seededFrom', 'Integration, entity type, direction and run parameters copied from {integration} — {entityType}. Batch size and full sync are at their defaults: a past run does not record them.', {
+                      integration: seedSource.integrationId,
+                      entityType: seedSource.entityType,
+                    })}
+                  </p>
+                  {seedSource.droppedKeys.length > 0 ? (
+                    <p>
+                      {t(
+                        seedSource.droppedKeys.length === 1
+                          ? 'data_sync.dashboard.start.seededDropped'
+                          : 'data_sync.dashboard.start.seededDroppedPlural',
+                        seedSource.droppedKeys.length === 1
+                          ? 'One stored parameter was not carried over: {keys} is no longer declared by {integration}.'
+                          : 'Some stored parameters were not carried over: {keys} are no longer declared by {integration}.',
+                        { keys: seedSource.droppedKeys.join(', '), integration: seedSource.integrationId },
+                      )}
+                    </p>
+                  ) : null}
+                </AlertDescription>
+              </Alert>
+            ) : null}
             <div className="grid gap-4 xl:grid-cols-3">
               <div className="space-y-2 xl:col-span-1">
                 <Label className="flex items-center gap-2 text-sm font-medium">
@@ -790,7 +1059,7 @@ export default function SyncRunsDashboardPage() {
                 </Label>
                 <Select
                   value={selectedIntegrationId || undefined}
-                  onValueChange={(value) => setSelectedIntegrationId(value ?? '')}
+                  onValueChange={(value) => { retireSeed(); setSelectedIntegrationId(value ?? '') }}
                   disabled={isLoadingOptions || options.length === 0}
                 >
                   <SelectTrigger size="lg">
@@ -818,7 +1087,7 @@ export default function SyncRunsDashboardPage() {
                 </Label>
                 <Select
                   value={selectedEntityType || undefined}
-                  onValueChange={(value) => setSelectedEntityType(value ?? '')}
+                  onValueChange={(value) => { retireSeed(); setSelectedEntityType(value ?? '') }}
                   disabled={entityOptions.length === 0}
                 >
                   <SelectTrigger size="lg">
@@ -840,7 +1109,7 @@ export default function SyncRunsDashboardPage() {
                 </Label>
                 <Select
                   value={selectedDirection}
-                  onValueChange={(value) => setSelectedDirection(value === 'export' ? 'export' : 'import')}
+                  onValueChange={(value) => { retireSeed(); setSelectedDirection(value === 'export' ? 'export' : 'import') }}
                   disabled={selectedIntegration?.direction !== 'bidirectional'}
                 >
                   <SelectTrigger size="lg">
@@ -977,7 +1246,7 @@ export default function SyncRunsDashboardPage() {
                       onValueChange={(value) => updateScheduleEditor({
                         scheduleType: value === 'cron' ? 'cron' : 'interval',
                       })}
-                      disabled={isLoadingSchedule || isSavingSchedule || isDeletingSchedule || !selectedIntegration || !selectedEntityType}
+                      disabled={scheduleControlsDisabled || !selectedIntegration || !selectedEntityType}
                     >
                       <SelectTrigger size="lg">
                         <SelectValue />
@@ -1000,7 +1269,7 @@ export default function SyncRunsDashboardPage() {
                     <Input
                       value={scheduleEditor.scheduleValue}
                       onChange={(event) => updateScheduleEditor({ scheduleValue: event.target.value })}
-                      disabled={isLoadingSchedule || isSavingSchedule || isDeletingSchedule || !selectedIntegration || !selectedEntityType}
+                      disabled={scheduleControlsDisabled || !selectedIntegration || !selectedEntityType}
                       placeholder={scheduleEditor.scheduleType === 'cron' ? '0 * * * *' : '1h'}
                       aria-invalid={scheduleValueError ? true : undefined}
                       aria-describedby={scheduleValueError ? SCHEDULE_VALUE_ERROR_ID : undefined}
@@ -1024,7 +1293,7 @@ export default function SyncRunsDashboardPage() {
                     <Input
                       value={scheduleEditor.timezone}
                       onChange={(event) => updateScheduleEditor({ timezone: event.target.value })}
-                      disabled={isLoadingSchedule || isSavingSchedule || isDeletingSchedule || !selectedIntegration || !selectedEntityType}
+                      disabled={scheduleControlsDisabled || !selectedIntegration || !selectedEntityType}
                     />
                   </div>
                 </div>
@@ -1041,7 +1310,7 @@ export default function SyncRunsDashboardPage() {
                       <Switch
                         checked={scheduleEditor.fullSync}
                         onCheckedChange={(checked) => updateScheduleEditor({ fullSync: checked })}
-                        disabled={isLoadingSchedule || isSavingSchedule || isDeletingSchedule || !selectedIntegration || !selectedEntityType}
+                        disabled={scheduleControlsDisabled || !selectedIntegration || !selectedEntityType}
                       />
                     </div>
                   </div>
@@ -1056,7 +1325,7 @@ export default function SyncRunsDashboardPage() {
                       <Switch
                         checked={scheduleEditor.isEnabled}
                         onCheckedChange={(checked) => updateScheduleEditor({ isEnabled: checked })}
-                        disabled={isLoadingSchedule || isSavingSchedule || isDeletingSchedule || !selectedIntegration || !selectedEntityType}
+                        disabled={scheduleControlsDisabled || !selectedIntegration || !selectedEntityType}
                       />
                     </div>
                   </div>
@@ -1079,7 +1348,7 @@ export default function SyncRunsDashboardPage() {
                       type="button"
                       variant="outline"
                       onClick={() => void handleDeleteSchedule()}
-                      disabled={!hasSavedSchedule || isDeletingSchedule}
+                      disabled={scheduleControlsDisabled || !hasSavedSchedule}
                     >
                       {isDeletingSchedule
                         ? t('data_sync.dashboard.schedule.deleting', 'Removing...')
@@ -1089,7 +1358,7 @@ export default function SyncRunsDashboardPage() {
                       type="button"
                       variant="outline"
                       onClick={() => void handleSaveSchedule()}
-                      disabled={isSavingSchedule || !selectedIntegration || !selectedEntityType}
+                      disabled={scheduleControlsDisabled || !selectedIntegration || !selectedEntityType}
                     >
                       <CalendarClock className="mr-2 size-4" />
                       {isSavingSchedule
@@ -1149,16 +1418,20 @@ export default function SyncRunsDashboardPage() {
                 label: t('data_sync.dashboard.actions.view'),
                 onSelect: () => { router.push(`/backend/data-sync/runs/${encodeURIComponent(row.id)}`) },
               },
-              ...(row.status === 'running' ? [{
+              ...(canRunSync && row.status === 'running' ? [{
                 id: 'cancel',
                 label: t('data_sync.runs.detail.cancel'),
                 destructive: true,
                 onSelect: () => { void handleCancel(row) },
               }] : []),
-              ...(row.status === 'failed' ? [{
-                id: 'retry',
-                label: t('data_sync.runs.detail.retry'),
-                onSelect: () => { void handleRetry(row) },
+              ...buildRetryActions(row),
+              // Completed only: on a failed run this differs from the
+              // from-scratch retry solely in offering an edit step, which does
+              // not earn a second near-identical item.
+              ...(canRunSync && row.status === 'completed' ? [{
+                id: 'run-again',
+                label: t('data_sync.dashboard.actions.runAgain', 'Run again…'),
+                onSelect: () => { router.push(`/backend/data-sync?from=${encodeURIComponent(row.id)}`) },
               }] : []),
             ]} />
           )}