@open-mercato/core 0.6.8-develop.6998.1.d2bc46c56c → 0.6.8-develop.7001.1.03608ab252

package/src/modules/warranty_claims/widgets/notifications/WarrantyClaimNotificationRenderer.tsx

@@ -0,0 +1,253 @@
+'use client'
+
+import * as React from 'react'
+import {
+  AlarmClock,
+  ClipboardCheck,
+  ExternalLink,
+  Loader2,
+  MessageSquare,
+  RefreshCw,
+  UserCheck,
+  X,
+  type LucideIcon,
+} from 'lucide-react'
+import { useRouter } from 'next/navigation'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { IconButton } from '@open-mercato/ui/primitives/icon-button'
+import { useLocale, useT, type TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+import { formatRelativeTime } from '@open-mercato/shared/lib/time'
+import { cn } from '@open-mercato/shared/lib/utils'
+import type { NotificationRendererProps } from '@open-mercato/shared/modules/notifications/types'
+
+type ClaimNotificationType =
+  | 'warranty_claims.claim.submitted'
+  | 'warranty_claims.claim.assigned'
+  | 'warranty_claims.claim.status_changed'
+  | 'warranty_claims.claim.escalated'
+  | 'warranty_claims.claim.customer_replied'
+
+type ClaimNotificationMeta = {
+  Icon: LucideIcon
+  titleKey: string
+  bodyKey: string
+  fallbackTitle: string
+  fallbackBody: string
+  tone: 'info' | 'warning'
+}
+
+const notificationMeta: Record<ClaimNotificationType, ClaimNotificationMeta> = {
+  'warranty_claims.claim.submitted': {
+    Icon: ClipboardCheck,
+    titleKey: 'warranty_claims.notifications.submitted.title',
+    bodyKey: 'warranty_claims.notifications.submitted.body',
+    fallbackTitle: 'Claim submitted',
+    fallbackBody: 'A warranty claim has been submitted for review.',
+    tone: 'info',
+  },
+  'warranty_claims.claim.assigned': {
+    Icon: UserCheck,
+    titleKey: 'warranty_claims.notifications.assigned.title',
+    bodyKey: 'warranty_claims.notifications.assigned.body',
+    fallbackTitle: 'Claim assigned',
+    fallbackBody: 'A warranty claim has been assigned.',
+    tone: 'info',
+  },
+  'warranty_claims.claim.status_changed': {
+    Icon: RefreshCw,
+    titleKey: 'warranty_claims.notifications.statusChanged.title',
+    bodyKey: 'warranty_claims.notifications.statusChanged.body',
+    fallbackTitle: 'Claim status changed',
+    fallbackBody: 'A warranty claim status changed.',
+    tone: 'warning',
+  },
+  'warranty_claims.claim.escalated': {
+    Icon: AlarmClock,
+    titleKey: 'warranty_claims.notifications.escalated.title',
+    bodyKey: 'warranty_claims.notifications.escalated.body',
+    fallbackTitle: 'Claim escalated',
+    fallbackBody: 'A warranty claim has been escalated.',
+    tone: 'warning',
+  },
+  'warranty_claims.claim.customer_replied': {
+    Icon: MessageSquare,
+    titleKey: 'warranty_claims.notifications.customerReplied.title',
+    bodyKey: 'warranty_claims.notifications.customerReplied.body',
+    fallbackTitle: 'Customer replied',
+    fallbackBody: 'A customer replied on a warranty claim.',
+    tone: 'info',
+  },
+}
+
+const toneClasses: Record<ClaimNotificationMeta['tone'], {
+  avatar: string
+  icon: string
+  border: string
+  unread: string
+}> = {
+  info: {
+    avatar: 'bg-status-info-bg',
+    icon: 'text-status-info-icon',
+    border: 'border-l-status-info-border',
+    unread: 'bg-status-info-bg',
+  },
+  warning: {
+    avatar: 'bg-status-warning-bg',
+    icon: 'text-status-warning-icon',
+    border: 'border-l-status-warning-border',
+    unread: 'bg-status-warning-bg',
+  },
+}
+
+function isClaimNotificationType(type: string): type is ClaimNotificationType {
+  return Object.prototype.hasOwnProperty.call(notificationMeta, type)
+}
+
+function getNotificationMeta(type: string): ClaimNotificationMeta {
+  return notificationMeta[isClaimNotificationType(type) ? type : 'warranty_claims.claim.submitted']
+}
+
+function fallbackText(value: string | null | undefined, key: string, fallback: string): string {
+  if (!value || value === key) return fallback
+  return value
+}
+
+function translateText(
+  t: TranslateFn,
+  key: string,
+  fallback: string,
+  variables: Record<string, string> | null | undefined,
+): string {
+  return t(key, fallback, variables ?? undefined)
+}
+
+function resolveClaimHref(notification: NotificationRendererProps['notification']): string {
+  if (notification.linkHref && !notification.linkHref.includes('{sourceEntityId}')) return notification.linkHref
+  if (notification.sourceEntityId) return `/backend/warranty_claims/${notification.sourceEntityId}`
+  return '/backend/warranty_claims'
+}
+
+export function WarrantyClaimNotificationRenderer({
+  notification,
+  onAction,
+  onDismiss,
+  actions = [],
+}: NotificationRendererProps) {
+  const t = useT()
+  const locale = useLocale()
+  const router = useRouter()
+  const [executing, setExecuting] = React.useState(false)
+  const meta = getNotificationMeta(notification.type)
+  const classes = toneClasses[meta.tone]
+  const isUnread = notification.status === 'unread'
+  const claimNumber = notification.bodyVariables?.claimNumber ?? notification.titleVariables?.claimNumber
+  const viewAction = actions.find((action) => action.id === 'view') ?? actions[0] ?? null
+  const href = resolveClaimHref(notification)
+  const timeAgo = formatRelativeTime(notification.createdAt, { locale }) ?? ''
+  const title = translateText(
+    t,
+    notification.titleKey ?? meta.titleKey,
+    fallbackText(notification.title, notification.titleKey ?? meta.titleKey, meta.fallbackTitle),
+    notification.titleVariables,
+  )
+  const body = translateText(
+    t,
+    notification.bodyKey ?? meta.bodyKey,
+    fallbackText(notification.body, notification.bodyKey ?? meta.bodyKey, meta.fallbackBody),
+    notification.bodyVariables,
+  )
+
+  const handleView = async () => {
+    if (!viewAction) {
+      router.push(href)
+      return
+    }
+    setExecuting(true)
+    try {
+      await onAction(viewAction.id)
+    } finally {
+      setExecuting(false)
+    }
+  }
+
+  return (
+    <div
+      className={cn(
+        'group relative flex items-start gap-3 rounded-xl border-l-4 p-3 transition-colors hover:bg-muted/40',
+        classes.border,
+        isUnread && classes.unread,
+      )}
+    >
+      <div className={cn('relative flex size-10 shrink-0 items-center justify-center rounded-full', classes.avatar)}>
+        <meta.Icon className={cn('size-5', classes.icon)} aria-hidden="true" />
+        {isUnread ? (
+          <span
+            className="absolute -right-1 -top-1 size-3 rounded-full bg-accent-indigo ring-2 ring-background"
+            aria-hidden="true"
+          />
+        ) : null}
+      </div>
+
+      <div className="flex min-w-0 flex-1 flex-col gap-1">
+        <p className="truncate text-sm font-medium leading-5 text-foreground">{title}</p>
+        <div className="flex flex-wrap items-center gap-1 text-xs leading-4 text-muted-foreground">
+          {timeAgo ? <span className="whitespace-nowrap">{timeAgo}</span> : null}
+          {timeAgo && claimNumber ? <span aria-hidden="true" className="text-text-disabled">—</span> : null}
+          {claimNumber ? (
+            <span className="inline-flex max-w-full items-center rounded bg-muted px-1.5 py-0.5 font-mono text-overline text-foreground">
+              <span className="truncate">#{claimNumber}</span>
+            </span>
+          ) : null}
+        </div>
+        {body ? (
+          <div className="mt-2 inline-flex max-w-full self-start rounded-tr-lg rounded-br-lg rounded-bl-lg rounded-tl-sm border border-border bg-background px-3 py-2 text-sm leading-5 text-muted-foreground shadow-xs">
+            <p className="line-clamp-2 break-words">{body}</p>
+          </div>
+        ) : null}
+        <div className="mt-2 flex flex-wrap items-center gap-2">
+          <Button
+            type="button"
+            size="sm"
+            className="gap-1.5"
+            onClick={(event) => {
+              event.stopPropagation()
+              handleView()
+            }}
+            disabled={executing}
+          >
+            <ExternalLink className="size-4" aria-hidden="true" />
+            {t('common.view', 'View')}
+            {executing ? <Loader2 className="size-3 animate-spin" aria-hidden="true" /> : null}
+          </Button>
+          <Button
+            type="button"
+            variant="ghost"
+            size="sm"
+            onClick={(event) => {
+              event.stopPropagation()
+              onDismiss()
+            }}
+          >
+            {t('notifications.actions.dismiss', 'Dismiss')}
+          </Button>
+        </div>
+      </div>
+
+      <IconButton
+        type="button"
+        variant="ghost"
+        size="xs"
+        className="absolute right-2 top-2 opacity-0 transition-opacity group-hover:opacity-100 focus-visible:opacity-100"
+        onClick={(event) => {
+          event.stopPropagation()
+          onDismiss()
+        }}
+        aria-label={t('notifications.actions.dismiss', 'Dismiss')}
+      >
+        <X className="size-4" aria-hidden="true" />
+      </IconButton>
+    </div>
+  )
+}
+
+export default WarrantyClaimNotificationRenderer

package/src/modules/warranty_claims/widgets/notifications/index.ts

@@ -0,0 +1 @@
+export { WarrantyClaimNotificationRenderer } from './WarrantyClaimNotificationRenderer'

package/src/modules/warranty_claims/workers/sla-escalation-sweep.ts

@@ -0,0 +1,450 @@
+import { randomUUID } from 'node:crypto'
+import type { FilterQuery } from '@mikro-orm/core'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { JobContext, QueuedJob, WorkerMeta } from '@open-mercato/queue'
+import type { AwilixContainer } from 'awilix'
+import type { CommandBus, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { buildFeatureNotificationFromType, buildNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import {
+  WarrantyClaim,
+  WarrantyClaimSlaSignal,
+  type WarrantyClaimSlaSignalEventId,
+} from '../data/entities'
+import { emitWarrantyClaimsEvent } from '../events'
+import { businessMillisBetween, slaProgressPctFromDue } from '../lib/businessHours'
+import {
+  isSlaEscalationCandidate,
+  parseEscalationTiers,
+  tiersToFire,
+  type EscalationTier,
+} from '../lib/escalation'
+import { resolveEffectiveWarrantyClaimSettings } from '../lib/settings'
+import { SLA_EXCLUDED_STATUSES } from '../lib/deskFilters'
+import { notificationTypes } from '../notifications'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('warranty_claims')
+
+type SlaEscalationSweepPayload = {
+  scope?: {
+    organizationId?: string | null
+    tenantId?: string | null
+  }
+}
+
+type ResolverContainer = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+type HandlerContext = JobContext & ResolverContainer & {
+  container?: ResolverContainer
+}
+
+type EscalateClaimCommandInput = {
+  id: string
+  organizationId: string
+  tenantId: string
+  toLevel: number
+  reassignToUserId?: string
+}
+
+type EscalateClaimCommandResult = {
+  claimId: string
+  escalationLevel: number
+  escalated: boolean
+}
+
+type SweepScope = {
+  tenantId: string
+  organizationId: string
+}
+
+// The active-SLA backlog grows with the tenant, so the sweep walks it in keyset
+// pages instead of decrypting every claim into memory in one query.
+const SWEEP_PAGE_SIZE = 500
+const SIGNAL_LEASE_MILLIS = 5 * 60 * 1000
+
+type SweepCursor = { slaDueAt: Date; id: string } | null
+
+function readCursor(claim: WarrantyClaim): SweepCursor {
+  return claim.slaDueAt ? { slaDueAt: claim.slaDueAt, id: claim.id } : null
+}
+
+// Keyset rather than offset: claims are mutated while the sweep runs, and
+// `slaDueAt` is not unique, so `(slaDueAt, id)` is the stable page boundary.
+function pageWhere(base: FilterQuery<WarrantyClaim>, cursor: SweepCursor): FilterQuery<WarrantyClaim> {
+  if (!cursor) return base
+  return {
+    $and: [
+      base,
+      {
+        $or: [
+          { slaDueAt: { $gt: cursor.slaDueAt } },
+          { slaDueAt: cursor.slaDueAt, id: { $gt: cursor.id } },
+        ],
+      },
+    ],
+  } as FilterQuery<WarrantyClaim>
+}
+
+export const metadata: WorkerMeta = {
+  queue: 'warranty_claims.sla_sweep',
+  id: 'warranty_claims:sla-escalation-sweep',
+  concurrency: 1,
+}
+
+function resolveContainer(ctx: HandlerContext): ResolverContainer {
+  return ctx.container ?? { resolve: ctx.resolve }
+}
+
+function readScope(payload: SlaEscalationSweepPayload): SweepScope | null {
+  const tenantId = payload.scope?.tenantId
+  const organizationId = payload.scope?.organizationId
+  if (typeof tenantId !== 'string' || tenantId.trim().length === 0) return null
+  if (typeof organizationId !== 'string' || organizationId.trim().length === 0) return null
+  return { tenantId: tenantId.trim(), organizationId: organizationId.trim() }
+}
+
+function claimEventPayload(claim: WarrantyClaim, scope: SweepScope): Record<string, unknown> {
+  return {
+    id: claim.id,
+    claimId: claim.id,
+    claimNumber: claim.claimNumber,
+    claimType: claim.claimType,
+    status: claim.status,
+    customerId: claim.customerId ?? null,
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+  }
+}
+
+function roundedPct(value: number): number {
+  return Math.round(value * 100) / 100
+}
+
+function slaSignalStamps(
+  eventId: WarrantyClaimSlaSignalEventId,
+  claim: WarrantyClaim,
+  now: Date,
+): Partial<Pick<WarrantyClaim, 'slaAtRiskNotifiedAt' | 'slaBreachedNotifiedAt'>> {
+  return eventId === 'warranty_claims.claim.sla_breached'
+    ? {
+        slaBreachedNotifiedAt: now,
+        slaAtRiskNotifiedAt: claim.slaAtRiskNotifiedAt ?? now,
+      }
+    : { slaAtRiskNotifiedAt: now }
+}
+
+async function reserveSlaSignal(
+  em: EntityManager,
+  eventId: WarrantyClaimSlaSignalEventId,
+  claim: WarrantyClaim,
+  scope: SweepScope,
+  progressPct: number,
+  elapsedBusinessMillis: number,
+  now: Date,
+): Promise<WarrantyClaimSlaSignal | null> {
+  const cycleKey = claim.slaDueAt?.toISOString()
+  if (!cycleKey) return null
+  const stamps = slaSignalStamps(eventId, claim, now)
+  const signal = await em.transactional(async (tx) => {
+    const affected = await tx.nativeUpdate(
+      WarrantyClaim,
+      {
+        id: claim.id,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+        ...(eventId === 'warranty_claims.claim.sla_breached'
+          ? { slaBreachedNotifiedAt: null }
+          : { slaAtRiskNotifiedAt: null }),
+      },
+      stamps,
+    )
+    if (affected === 0) return null
+
+    const created = tx.create(WarrantyClaimSlaSignal, {
+      id: randomUUID(),
+      claimId: claim.id,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      eventId,
+      cycleKey,
+      payload: {
+        ...claimEventPayload(claim, scope),
+        progressPct: roundedPct(progressPct),
+        elapsedBusinessMillis,
+        slaDueAt: claim.slaDueAt?.toISOString() ?? null,
+      },
+    })
+    await tx.persist(created).flush()
+    return created
+  })
+  if (signal) Object.assign(claim, stamps)
+  return signal
+}
+
+async function acquireSlaSignalLease(
+  em: EntityManager,
+  signal: WarrantyClaimSlaSignal,
+): Promise<string | null> {
+  const leaseToken = randomUUID()
+  const now = new Date()
+  const affected = await em.nativeUpdate(
+    WarrantyClaimSlaSignal,
+    {
+      id: signal.id,
+      tenantId: signal.tenantId,
+      organizationId: signal.organizationId,
+      publishedAt: null,
+      $or: [
+        { leaseExpiresAt: null },
+        { leaseExpiresAt: { $lt: now } },
+      ],
+    },
+    {
+      leaseToken,
+      leaseExpiresAt: new Date(now.getTime() + SIGNAL_LEASE_MILLIS),
+    },
+  )
+  return affected === 0 ? null : leaseToken
+}
+
+async function publishSlaSignal(em: EntityManager, signal: WarrantyClaimSlaSignal): Promise<void> {
+  const leaseToken = await acquireSlaSignalLease(em, signal)
+  if (!leaseToken) return
+  try {
+    await emitWarrantyClaimsEvent(
+      signal.eventId,
+      { ...signal.payload, deliveryId: signal.id },
+      {
+        persistent: true,
+        tenantId: signal.tenantId,
+        organizationId: signal.organizationId,
+      },
+    )
+    const affected = await em.nativeUpdate(
+      WarrantyClaimSlaSignal,
+      { id: signal.id, leaseToken, publishedAt: null },
+      { publishedAt: new Date(), leaseToken: null, leaseExpiresAt: null },
+    )
+    if (affected === 0) {
+      throw new Error('[internal] SLA signal publication lease was lost')
+    }
+  } catch (error) {
+    await em.nativeUpdate(
+      WarrantyClaimSlaSignal,
+      { id: signal.id, leaseToken, publishedAt: null },
+      { leaseToken: null, leaseExpiresAt: null },
+    ).catch(() => undefined)
+    throw error
+  }
+}
+
+async function drainPendingSlaSignals(em: EntityManager, scope: SweepScope): Promise<void> {
+  const pending = await findWithDecryption(
+    em,
+    WarrantyClaimSlaSignal,
+    { tenantId: scope.tenantId, organizationId: scope.organizationId, publishedAt: null },
+    { orderBy: { createdAt: 'ASC' }, limit: SWEEP_PAGE_SIZE },
+    scope,
+  )
+  for (const signal of pending) {
+    try {
+      await publishSlaSignal(em, signal)
+    } catch (error) {
+      logger.warn('[warranty_claims:sla-escalation-sweep] pending signal failed', {
+        signalId: signal.id,
+        claimId: signal.claimId,
+        error: error instanceof Error ? error.message : error,
+      })
+    }
+  }
+}
+
+function buildCommandContext(container: ResolverContainer, scope: SweepScope): CommandRuntimeContext {
+  return {
+    container: container as unknown as AwilixContainer,
+    auth: null,
+    organizationScope: null,
+    selectedOrganizationId: scope.organizationId,
+    organizationIds: [scope.organizationId],
+    systemActor: true,
+  }
+}
+
+async function createEscalationNotification(
+  container: ResolverContainer,
+  claim: WarrantyClaim,
+  scope: SweepScope,
+  tierIndex: number,
+  progressPct: number,
+): Promise<void> {
+  const typeDef = notificationTypes.find((type) => type.type === 'warranty_claims.claim.escalated')
+  if (!typeDef) return
+
+  const notificationService = resolveNotificationService(container)
+  const common = {
+    bodyVariables: {
+      claimNumber: claim.claimNumber,
+      level: String(tierIndex),
+      progressPct: String(Math.round(progressPct)),
+    },
+    sourceEntityType: 'warranty_claims:warranty_claim',
+    sourceEntityId: claim.id,
+    linkHref: `/backend/warranty_claims/${claim.id}`,
+    groupKey: `warranty_claims.claim.escalated:${claim.id}:${tierIndex}`,
+  }
+
+  if (claim.assigneeUserId) {
+    await notificationService.create(buildNotificationFromType(typeDef, {
+      ...common,
+      recipientUserId: claim.assigneeUserId,
+    }), scope)
+  }
+
+  await notificationService.createForFeature(buildFeatureNotificationFromType(typeDef, {
+    ...common,
+    requiredFeature: 'warranty_claims.claim.manage',
+  }), scope)
+}
+
+async function runEscalationTier(
+  container: ResolverContainer,
+  scope: SweepScope,
+  claim: WarrantyClaim,
+  tierIndex: number,
+  tier: EscalationTier,
+  progressPct: number,
+): Promise<void> {
+  if (tier.action === 'notify') {
+    await createEscalationNotification(container, claim, scope, tierIndex, progressPct)
+  }
+  const commandBus = container.resolve<CommandBus>('commandBus')
+  const input: EscalateClaimCommandInput = {
+    id: claim.id,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    toLevel: tierIndex,
+    ...(tier.action === 'reassign' && tier.toUserId ? { reassignToUserId: tier.toUserId } : {}),
+  }
+  const { result } = await commandBus.execute<EscalateClaimCommandInput, EscalateClaimCommandResult>(
+    'warranty_claims.claim.escalate',
+    { input, ctx: buildCommandContext(container, scope) },
+  )
+  if (!result.escalated) return
+  if (tier.action === 'reassign' && tier.toUserId) {
+    claim.assigneeUserId = tier.toUserId
+  }
+}
+
+function logClaimSweepError(claimId: string, error: unknown): void {
+  logger.warn('[warranty_claims:sla-escalation-sweep] claim failed', {
+    claimId,
+    error: error instanceof Error ? error.message : error,
+  })
+}
+
+export default async function handle(
+  job: QueuedJob<SlaEscalationSweepPayload>,
+  ctx: HandlerContext,
+): Promise<void> {
+  const scope = readScope(job.payload)
+  if (!scope) return
+
+  const container = resolveContainer(ctx)
+  const em = ctx.resolve<EntityManager>('em')
+  try {
+    await drainPendingSlaSignals(em, scope)
+  } catch (error) {
+    logger.error('[warranty_claims:sla-escalation-sweep] pending signal drain failed', {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      error: error instanceof Error ? error.message : error,
+    })
+  }
+  const settings = await resolveEffectiveWarrantyClaimSettings(em, scope)
+  const tiers = parseEscalationTiers(settings.escalationTiers)
+  const now = new Date()
+
+  const baseWhere: FilterQuery<WarrantyClaim> = {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    deletedAt: null,
+    slaPausedAt: null,
+    slaDueAt: { $ne: null },
+    submittedAt: { $ne: null },
+    status: { $nin: [...SLA_EXCLUDED_STATUSES] },
+  }
+
+  let cursor: SweepCursor = null
+  for (;;) {
+    const claims = await findWithDecryption(
+      em,
+      WarrantyClaim,
+      pageWhere(baseWhere, cursor),
+      { orderBy: { slaDueAt: 'ASC', id: 'ASC' }, limit: SWEEP_PAGE_SIZE },
+      scope,
+    )
+    if (!claims.length) break
+
+    for (const claim of claims) {
+      if (!isSlaEscalationCandidate(claim)) continue
+      const submittedAt = claim.submittedAt
+      const slaDueAt = claim.slaDueAt
+      if (!submittedAt || !slaDueAt) continue
+      try {
+        const elapsedBusinessMillis = businessMillisBetween(submittedAt, now, settings.businessHours)
+        // Anchor progress on `slaDueAt` — the pause-shifted deadline the stats
+        // endpoint reads — so pause/resume and escalation share one time base.
+        const progressPct = slaProgressPctFromDue(now, slaDueAt, settings.slaHours, settings.businessHours)
+
+        if (
+          progressPct >= settings.slaAtRiskThresholdPct &&
+          progressPct < 100 &&
+          !claim.slaAtRiskNotifiedAt
+        ) {
+          const signal = await reserveSlaSignal(
+            em,
+            'warranty_claims.claim.sla_at_risk',
+            claim,
+            scope,
+            progressPct,
+            elapsedBusinessMillis,
+            now,
+          )
+          if (signal) await publishSlaSignal(em, signal)
+        }
+        if (progressPct >= 100 && !claim.slaBreachedNotifiedAt) {
+          const signal = await reserveSlaSignal(
+            em,
+            'warranty_claims.claim.sla_breached',
+            claim,
+            scope,
+            progressPct,
+            elapsedBusinessMillis,
+            now,
+          )
+          if (signal) await publishSlaSignal(em, signal)
+        }
+
+        const fire = tiersToFire(progressPct, claim.escalationLevel ?? 0, tiers)
+        for (const entry of fire) {
+          await runEscalationTier(container, scope, claim, entry.tierIndex, entry.tier, progressPct)
+        }
+      } catch (error) {
+        logClaimSweepError(claim.id, error)
+      }
+    }
+
+    if (claims.length < SWEEP_PAGE_SIZE) break
+    const nextCursor = readCursor(claims[claims.length - 1])
+    if (!nextCursor) break
+    cursor = nextCursor
+    // Release the decrypted page before fetching the next one; every write in
+    // the loop goes through `nativeUpdate` or its own command fork, so nothing
+    // depends on these entities staying managed.
+    em.clear()
+  }
+}