@open-mercato/core 0.6.8-develop.6993.1.3fc50f3409 → 0.6.8-develop.7000.1.0ae682bad1

package/src/modules/customers/lib/assignableStaff.ts

@@ -0,0 +1,177 @@
+import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import type { FilterOption } from '@open-mercato/shared/lib/query/advanced-filter'
+
+export type AssignableStaffMember = {
+  teamMemberId: string
+  userId: string
+  displayName: string
+  email: string | null
+  teamName: string | null
+}
+
+type AssignableStaffResponse = {
+  items?: Array<Record<string, unknown>>
+  total?: number
+  page?: number
+  pageSize?: number
+}
+
+export type AssignableStaffMembersPage = {
+  items: AssignableStaffMember[]
+  /**
+   * How many rows the server served for this page, before the dedupe below.
+   * "Load more" guards must measure this rather than `items.length`: a deduped
+   * length shorter than the served page reads as a short page and terminates
+   * the sequence early, stranding the rest of the roster.
+   */
+  servedCount: number
+  total: number
+  page: number
+  pageSize: number
+}
+
+// The assignable-staff roster is owned by the optional, ejectable `staff` module.
+// When that module is disabled, its `/api/staff/team-members/assignable` endpoint is
+// absent and the request resolves to 404. Customers UI (deals / people / companies
+// owner filters, role-assignment dialogs) is core and always enabled, so it must not
+// break in that case — a missing staff module simply means there is no roster to
+// offer. Treat the 404 as an empty page and let any other failure propagate.
+function isAssignableEndpointMissing(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    (error as { status?: unknown }).status === 404
+  )
+}
+
+export async function fetchAssignableStaffMembersPage(
+  query: string,
+  options?: { page?: number; pageSize?: number; signal?: AbortSignal },
+): Promise<AssignableStaffMembersPage> {
+  const page = options?.page ?? 1
+  const pageSize = options?.pageSize ?? 24
+  const params = new URLSearchParams()
+  params.set('page', String(page))
+  params.set('pageSize', String(pageSize))
+  const normalizedQuery = query.trim()
+  if (normalizedQuery.length > 0) {
+    params.set('search', normalizedQuery)
+  }
+
+  let data: AssignableStaffResponse
+  try {
+    data = await readApiResultOrThrow<AssignableStaffResponse>(
+      `/api/staff/team-members/assignable?${params.toString()}`,
+      options?.signal ? { signal: options.signal } : undefined,
+    )
+  } catch (error) {
+    if (isAssignableEndpointMissing(error)) {
+      return { items: [], servedCount: 0, total: 0, page, pageSize }
+    }
+    throw error
+  }
+
+  const rawItems = Array.isArray(data?.items) ? data.items : []
+  const deduped = new Map<string, AssignableStaffMember>()
+
+  for (const item of rawItems) {
+    const userId =
+      typeof item?.userId === 'string'
+        ? item.userId
+        : typeof item?.user_id === 'string'
+          ? item.user_id
+          : null
+    if (!userId || deduped.has(userId)) continue
+
+    const user =
+      item?.user && typeof item.user === 'object'
+        ? (item.user as Record<string, unknown>)
+        : null
+    const team =
+      item?.team && typeof item.team === 'object'
+        ? (item.team as Record<string, unknown>)
+        : null
+
+    const displayName =
+      typeof item?.displayName === 'string' && item.displayName.trim().length > 0
+        ? item.displayName.trim()
+        : typeof item?.display_name === 'string' && item.display_name.trim().length > 0
+          ? item.display_name.trim()
+          : null
+    const email =
+      user && typeof user.email === 'string' && user.email.trim().length > 0
+        ? user.email.trim()
+        : typeof item?.email === 'string' && item.email.trim().length > 0
+          ? item.email.trim()
+          : null
+    const teamName =
+      typeof item?.teamName === 'string' && item.teamName.trim().length > 0
+        ? item.teamName.trim()
+        : typeof item?.team_name === 'string' && item.team_name.trim().length > 0
+          ? item.team_name.trim()
+          : team && typeof team.name === 'string' && team.name.trim().length > 0
+            ? team.name.trim()
+            : null
+    const teamMemberId =
+      typeof item?.teamMemberId === 'string'
+        ? item.teamMemberId
+        : typeof item?.team_member_id === 'string'
+          ? item.team_member_id
+          : typeof item?.id === 'string'
+            ? item.id
+            : userId
+
+    deduped.set(userId, {
+      teamMemberId,
+      userId,
+      displayName: displayName ?? email ?? userId,
+      email,
+      teamName,
+    })
+  }
+
+  return {
+    items: Array.from(deduped.values()),
+    servedCount: rawItems.length,
+    total:
+      typeof data?.total === 'number' && Number.isFinite(data.total)
+        ? data.total
+        : deduped.size,
+    page:
+      typeof data?.page === 'number' && Number.isFinite(data.page)
+        ? data.page
+        : page,
+    pageSize:
+      typeof data?.pageSize === 'number' && Number.isFinite(data.pageSize)
+        ? data.pageSize
+        : pageSize,
+  }
+}
+
+export async function fetchAssignableStaffMembers(
+  query: string,
+  options?: { pageSize?: number; signal?: AbortSignal },
+): Promise<AssignableStaffMember[]> {
+  const result = await fetchAssignableStaffMembersPage(query, options)
+  return result.items
+}
+
+export function mapAssignableStaffToFilterOptions(items: AssignableStaffMember[]): FilterOption[] {
+  return items.map((item) => ({
+    value: item.userId,
+    label: item.email && item.email !== item.displayName
+      ? `${item.displayName} (${item.email})`
+      : item.displayName,
+    tone: 'neutral',
+  }))
+}
+
+export function ensureCurrentUserFilterOption(
+  options: FilterOption[],
+  currentUserId: string,
+  fallbackLabel: string,
+): FilterOption[] {
+  const trimmed = currentUserId.trim()
+  if (!trimmed || options.some((option) => option.value === trimmed)) return options
+  return [{ value: trimmed, label: fallbackLabel, tone: 'neutral' }, ...options]
+}

package/src/modules/data_sync/AGENTS.md

@@ -54,6 +54,8 @@ packages/core/src/modules/data_sync/
 │   ├── adapter-registry.ts      # Register/get adapters by providerKey
 │   ├── id-mapping.ts            # External ID ↔ local ID lookup and storage
 │   ├── 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
 │   ├── sync-engine.ts           # Orchestrates streaming import/export with progress
 │   └── sync-run-service.ts      # CRUD for SyncRun + cursor management
 ├── api/
@@ -97,23 +99,97 @@ Provider modules implement `DataSyncAdapter`:
 
 ```typescript
 interface DataSyncAdapter {
-  providerKey: string
-  direction: 'import' | 'export' | 'bidirectional'
-  supportedEntities: string[]
-  streamImport(entityType: string, cursor: string | null, config: SyncConfig): AsyncIterable<ImportBatch>
-  streamExport?(entityType: string, cursor: string | null, config: SyncConfig): AsyncIterable<ExportBatch>
-  getInitialCursor?(entityType: string): Promise<string | null>
-  getMapping?(entityType: string): Promise<FieldMapping[]>
+  readonly providerKey: string
+  readonly direction: 'import' | 'export' | 'bidirectional'
+  readonly supportedEntities: string[]
+  readonly runMode?: 'generic' | 'provider'
+  readonly operationalTelemetry?: boolean
+  readonly runParameters?: RunParameter[]
+
+  streamImport?(input: StreamImportInput): AsyncIterable<ImportBatch>
+  streamExport?(input: StreamExportInput): AsyncIterable<ExportBatch>
+  getInitialCursor?(input: { entityType: string; scope: TenantScope }): Promise<string | null>
+  getMapping(input: { entityType: string; scope: TenantScope }): Promise<DataMapping>
   persistsSharedCursor?(entityType: string): boolean
-  validateConnection?(credentials: Record<string, unknown>): Promise<{ valid: boolean; message?: string }>
+  validateConnection?(input: {
+    entityType: string
+    credentials: Record<string, unknown>
+    mapping: DataMapping
+    scope: TenantScope
+  }): Promise<ValidationResult>
 }
 ```
 
+All hooks take a single input object — see `lib/adapter.ts` for the authoritative
+shapes.
+
 Register adapters in your provider module's `di.ts`:
 ```typescript
 registerDataSyncAdapter(myAdapter)
 ```
 
+### Run parameters
+
+Adapters may declare optional, operator-facing `runParameters`. The dashboard
+renders a generic input per declared parameter, the run API validates and
+coerces the submitted values against the declaration (`lib/run-parameters.ts`),
+and the normalized values are persisted on the run and passed back on
+`StreamImportInput.parameters` / `StreamExportInput.parameters`. Keep
+declarations provider-agnostic — never special-case a provider in `data_sync`.
+
+```typescript
+runParameters: [
+  { key: 'dryRun', label: 'Dry run', type: 'boolean', defaultValue: false,
+    description: 'Report what would change without writing.' },
+  { key: 'startId', label: 'Start id', type: 'number', min: 0 },
+  { key: 'mode', label: 'Mode', type: 'select',
+    options: [{ value: 'fast' }, { value: 'thorough' }] },
+  // Only offered when the orders entity is selected:
+  { key: 'bulk', label: 'Bulk reindex', type: 'boolean', entityType: 'sales_orders' },
+]
+```
+
+Supported types: `boolean`, `string`, `number`, `select`. A parameter may set
+`direction` to apply to only `import` or `export` runs, and `entityType`
+(a `supportedEntities` value or an array of them) to apply only when that
+entity is selected — use it when a knob only makes sense for one entity's run.
+Params without `direction` / `entityType` apply to every run. Blank values fall
+back to `defaultValue`; values are retained across retries.
+
+Run parameters are **operator-visible and stored in clear text** on
+`sync_runs.parameters`, and rendered read-only on the run detail page. Never
+declare a parameter that carries a secret — credentials belong in
+`integrationCredentialsService`.
+
+**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
+back to the literal. Validation failures come back from the API as
+`{ key, code, params, message }` — the UI renders `code` through
+`data_sync.runParameters.errors.<code>` and only uses the English `message` as
+a fallback, so never rely on the sentence text.
+
+**Retry re-validates.** `POST /api/data_sync/runs/[id]/retry` re-runs the stored
+values through `normalizeRunParameters` against the *current* declaration:
+parameters you have since removed or re-scoped fall away, and a value that no
+longer satisfies its declaration fails the retry with a 422 instead of reaching
+the adapter. An adapter therefore never receives a set the run API would reject
+today — tighten a bound freely.
+
+The integration detail page's schedule table also starts runs, but has no room
+for a parameter form: it submits the declared defaults and refuses the run when
+an applicable parameter is `required` with no `defaultValue`, pointing the
+operator at the Data Sync dashboard. Declare a `defaultValue` for anything that
+should stay launchable from that table.
+
+**Recurring runs get your defaults, not operator values.** A `SyncSchedule`
+cannot yet pin a chosen value, but the scheduled worker normalizes an empty
+input against your declaration, so a scheduled run hands you the same set an
+untouched dashboard form would — never an empty object. Write your adapter
+against the defaults, not against `undefined`. A default that violates its own
+declaration skips the scheduled run with a logged error instead of starting it
+with a half-applied set.
+
 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
@@ -131,6 +207,8 @@ If the sync provider needs bootstrap credentials, mappings, locales, channels, o
 - **Resume**: Retry reads the last successful cursor, resumes from there
 - **Progress**: Linked to `ProgressJob` via `progressJobId` for `ProgressTopBar` display
 - **Cancellation**: Via `progressService.isCancellationRequested()`
+- **Tracing**: The engine emits one **root** span per batch (`data_sync.import.batch` / `data_sync.export.batch`) linked back to the run, covering the adapter's read *and* the engine's bookkeeping. Adapters MUST NOT hand-roll their own batch span — they cannot root it, so a multi-day run would ride on the single sampling decision taken for the request that triggered it. Inner spans an adapter creates nest under the batch span normally. The final read — the one that finds the stream drained — is traced as `data_sync.import.drain` / `data_sync.export.drain`, so N batches emit exactly N `*.batch` spans plus one `*.drain`.
+- **Stream shape**: The engine drives the adapter's async iterator explicitly (`batch-stream.ts`) so the span wraps `next()`, where a generator does its real work before yielding. Closing follows the language's own `IteratorClose` rules, so `finally` blocks in an adapter generator behave exactly as under `for await`: no `return()` when the stream exhausts or `next()` throws (already closed), `return()` with its failure surfaced on an early stop, and `return()` with its failure swallowed when the engine's own handler threw (that error wins). Keep cleanup in `finally`.
 
 ## Queue Names
 

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

@@ -55,6 +55,7 @@ export async function GET(req: Request) {
           runMode: adapter.runMode ?? 'generic',
           canStartRun: adapter.runMode !== 'provider',
           supportedEntities: adapter.supportedEntities,
+          runParameters: adapter.runParameters ?? [],
           hasCredentials: Boolean(credentials),
           isEnabled,
           settingsPath: `/backend/integrations/${encodeURIComponent(integration.id)}`,

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 { normalizeRunParameters } from '../lib/run-parameters'
 import { resolveStartCursor } from '../lib/start-cursor'
 import {
   runCrudMutationGuardAfterSuccess,
@@ -78,6 +79,19 @@ export async function POST(req: Request) {
       return NextResponse.json({ error: 'Unsupported entity type for this integration' }, { status: 422 })
     }
 
+    const normalizedParameters = normalizeRunParameters(
+      adapter.runParameters,
+      parsed.data.direction,
+      parsed.data.parameters,
+      parsed.data.entityType,
+    )
+    if (!normalizedParameters.ok) {
+      return NextResponse.json(
+        { error: 'Invalid run parameters', details: { parameters: normalizedParameters.errors } },
+        { status: 422 },
+      )
+    }
+
     const integrationEnabled = await integrationStateService.isEnabled(parsed.data.integrationId, scope)
     if (!integrationEnabled) {
       return NextResponse.json({ error: 'Integration is disabled' }, { status: 409 })
@@ -133,6 +147,9 @@ export async function POST(req: Request) {
         cursor,
         triggeredBy: parsed.data.triggeredBy ?? auth.sub,
         batchSize: parsed.data.batchSize,
+        parameters: Object.keys(normalizedParameters.values).length > 0
+          ? normalizedParameters.values
+          : null,
       },
     })
 

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 { normalizeRunParameters } from '../../../lib/run-parameters'
 import { resolveAdapterForIntegration, resolveStartCursor } from '../../../lib/start-cursor'
 import {
   runCrudMutationGuardAfterSuccess,
@@ -88,11 +89,40 @@ export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }
     return NextResponse.json(guardResult.body, { status: guardResult.status })
   }
 
+  // A retry replays the stored parameters, but the adapter's declaration may
+  // have moved on since the original run — a parameter dropped, a bound
+  // tightened, a select option removed, a scope narrowed. Re-normalize against
+  // the current declaration so an adapter never receives a set the run API
+  // would reject today. Undeclared keys fall away silently; values that are now
+  // invalid stop the retry, because the operator has no form here to fix them.
+  const retryAdapter = resolveAdapterForIntegration(previous.integrationId)
+  const normalizedParameters = normalizeRunParameters(
+    retryAdapter?.runParameters,
+    previous.direction,
+    previous.parameters ?? null,
+    previous.entityType,
+  )
+  if (!normalizedParameters.ok) {
+    return NextResponse.json(
+      {
+        error: 'Stored run parameters are no longer valid for this integration. Start a new run from the Data Sync dashboard.',
+        // Machine-readable so the dashboard can render the way out in the
+        // operator's language; the English sentence stays for non-UI callers.
+        code: 'parametersStale',
+        details: { parameters: normalizedParameters.errors },
+      },
+      { status: 422 },
+    )
+  }
+  const retryParameters = Object.keys(normalizedParameters.values).length > 0
+    ? normalizedParameters.values
+    : null
+
   const cursor = parsedBody.data.fromBeginning
     ? null
     : previous.cursor ?? await resolveStartCursor({
       syncRunService,
-      adapter: resolveAdapterForIntegration(previous.integrationId),
+      adapter: retryAdapter,
       integrationId: previous.integrationId,
       entityType: previous.entityType,
       direction: previous.direction,
@@ -113,6 +143,7 @@ export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }
       cursor,
       triggeredBy: auth.sub,
       batchSize: 100,
+      parameters: retryParameters,
       progressJob: {
         name: `Retry data sync ${previous.integrationId} — ${previous.entityType}`,
       },

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

@@ -69,6 +69,7 @@ export async function GET(req: Request, ctx: { params?: Promise<{ id?: string }>
     batchesCompleted: run.batchesCompleted,
     lastError: run.lastError ?? null,
     progressJobId: run.progressJobId ?? null,
+    parameters: run.parameters ?? null,
     progressJob: progressJob
       ? {
         id: progressJob.id,

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

@@ -44,6 +44,18 @@ import {
   ShieldCheck,
 } from 'lucide-react'
 import { getSyncRunStatusVariant, getSyncSummaryVariant } from '../../lib/syncRunStatus'
+import type { RunParameter } from '../../lib/adapter'
+import { getApplicableRunParameters } from '../../lib/run-parameters'
+import {
+  RunParameterFields,
+  buildDefaultRunParameterValues,
+  buildRetryFailureMessage,
+  buildRunFailureMessage,
+  buildRunParametersPayload,
+  type RetryFailureBody,
+  type RunFailureBody,
+  type RunParameterFormValue,
+} from '../../components/RunParameterFields'
 
 type SyncRunRow = {
   id: string
@@ -73,6 +85,7 @@ type SyncOption = {
   runMode?: 'generic' | 'provider'
   canStartRun?: boolean
   supportedEntities: string[]
+  runParameters?: RunParameter[]
   hasCredentials: boolean
   isEnabled: boolean
   settingsPath: string
@@ -149,6 +162,7 @@ export default function SyncRunsDashboardPage() {
   const [selectedDirection, setSelectedDirection] = React.useState<'import' | 'export'>('import')
   const [batchSize, setBatchSize] = React.useState('100')
   const [fullSync, setFullSync] = React.useState(false)
+  const [paramValues, setParamValues] = React.useState<Record<string, RunParameterFormValue>>({})
   const [scheduleEditor, setScheduleEditor] = React.useState<SyncScheduleEditorState>(() => buildDefaultScheduleState(''))
   const [isLoadingSchedule, setIsLoadingSchedule] = React.useState(false)
   const [isSavingSchedule, setIsSavingSchedule] = React.useState(false)
@@ -231,6 +245,27 @@ export default function SyncRunsDashboardPage() {
     [selectedIntegration],
   )
 
+  const runParameters = React.useMemo(
+    () => getApplicableRunParameters(
+      selectedIntegration?.runParameters,
+      selectedDirection,
+      // Pass the state through as-is. Before an entity is chosen it is '',
+      // which matches no `entityType` and so hides scoped parameters — the
+      // wanted outcome. Mapping '' to `undefined` would mean "skip entity
+      // scoping" and show every scoped parameter instead.
+      selectedEntityType,
+    ),
+    [selectedIntegration, selectedDirection, selectedEntityType],
+  )
+
+  React.useEffect(() => {
+    setParamValues(buildDefaultRunParameterValues(runParameters))
+  }, [runParameters])
+
+  const updateParamValue = React.useCallback((key: string, value: RunParameterFormValue) => {
+    setParamValues((current) => ({ ...current, [key]: value }))
+  }, [])
+
   React.useEffect(() => {
     if (!selectedIntegration) {
       setSelectedEntityType('')
@@ -325,7 +360,7 @@ export default function SyncRunsDashboardPage() {
       flash(t('data_sync.runs.detail.retrySuccess'), 'success')
       setReloadToken((token) => token + 1)
     } else {
-      flash(t('data_sync.runs.detail.retryError'), 'error')
+      flash(buildRetryFailureMessage(call.result as RetryFailureBody | null, t), 'error')
     }
   }, [t])
 
@@ -352,27 +387,25 @@ export default function SyncRunsDashboardPage() {
       return
     }
 
+    const parameters = buildRunParametersPayload(runParameters, paramValues)
+    const requestBody: Record<string, unknown> = {
+      integrationId: selectedIntegration.integrationId,
+      entityType: selectedEntityType,
+      direction: selectedDirection,
+      batchSize: parsedBatchSize,
+      fullSync,
+    }
+    if (runParameters.length > 0) requestBody.parameters = parameters
+
     try {
       const call = await runMutation({
         // optimistic-lock-exempt: starts a new sync run (create), not a concurrent record edit
         operation: () => apiCall<{ id: string }>('/api/data_sync/run', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            integrationId: selectedIntegration.integrationId,
-            entityType: selectedEntityType,
-            direction: selectedDirection,
-            batchSize: parsedBatchSize,
-            fullSync,
-          }),
+          body: JSON.stringify(requestBody),
         }, { fallback: null }),
-        mutationPayload: {
-          integrationId: selectedIntegration.integrationId,
-          entityType: selectedEntityType,
-          direction: selectedDirection,
-          batchSize: parsedBatchSize,
-          fullSync,
-        },
+        mutationPayload: requestBody,
         context: {
           operation: 'create',
           actionId: 'start-sync-run',
@@ -381,7 +414,11 @@ export default function SyncRunsDashboardPage() {
       })
 
       if (!call.ok || !call.result?.id) {
-        flash((call.result as { error?: string } | null)?.error ?? t('data_sync.dashboard.start.error', 'Failed to start sync run'), 'error')
+        flash(buildRunFailureMessage(
+          call.result as RunFailureBody | null,
+          t('data_sync.dashboard.start.error', 'Failed to start sync run'),
+          t,
+        ), 'error')
         return
       }
 
@@ -392,7 +429,7 @@ export default function SyncRunsDashboardPage() {
       const message = error instanceof Error ? error.message : t('data_sync.dashboard.start.error', 'Failed to start sync run')
       flash(message, 'error')
     }
-  }, [batchSize, fullSync, router, runMutation, selectedDirection, selectedEntityType, selectedIntegration, t])
+  }, [batchSize, fullSync, paramValues, router, runMutation, runParameters, selectedDirection, selectedEntityType, selectedIntegration, t])
 
   const handleSaveSchedule = React.useCallback(async () => {
     if (!selectedIntegration || !selectedEntityType) return
@@ -784,6 +821,25 @@ export default function SyncRunsDashboardPage() {
                   </div>
                 </div>
 
+                {runParameters.length > 0 ? (
+                  <div className="mt-4 space-y-3">
+                    <div className="flex items-center gap-2">
+                      <Settings2 className="size-4 text-muted-foreground" />
+                      <h4 className="text-sm font-semibold">
+                        {t('data_sync.dashboard.start.parameters', 'Run parameters')}
+                      </h4>
+                    </div>
+                    <p className="text-xs text-muted-foreground">
+                      {t('data_sync.dashboard.start.parametersHelp', 'Optional values this integration accepts for the manual run.')}
+                    </p>
+                    <RunParameterFields
+                      params={runParameters}
+                      values={paramValues}
+                      onChange={updateParamValue}
+                    />
+                  </div>
+                ) : null}
+
                 <div className="mt-4 flex flex-wrap items-center justify-between gap-3">
                   <p className="text-xs text-muted-foreground">
                     {t('data_sync.dashboard.start.runNowFootnote', 'Manual runs show progress immediately and land on the run detail page after launch.')}