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

package/src/modules/warranty_claims/services/adjudicationEvaluator.ts

@@ -0,0 +1,344 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { WarrantyClaimEffectiveSettings } from '../lib/settings'
+import type { ClaimRiskAssessment } from '../lib/risk'
+import type { WarrantyClaim, WarrantyClaimLine } from '../data/entities'
+import { tryResolve } from '../lib/tryResolve'
+
+export interface WarrantyAdjudicationDecision {
+  decision: 'auto_approve' | 'manual_review'
+  facts: Record<string, unknown>
+}
+
+export interface WarrantyAdjudicationEvaluator {
+  evaluate(args: {
+    claim: WarrantyClaim
+    lines: WarrantyClaimLine[]
+    settings: WarrantyClaimEffectiveSettings
+    risk: ClaimRiskAssessment
+    container: { resolve: <R = unknown>(n: string) => R }
+    em: EntityManager
+    scope: { tenantId: string; organizationId: string }
+  }): Promise<WarrantyAdjudicationDecision>
+}
+
+type BusinessRulesClaimData = {
+  claim: Record<string, unknown>
+  lines: Array<Record<string, unknown>>
+  settings: Record<string, unknown>
+  risk: ClaimRiskAssessment
+}
+
+type BusinessRulesClaimEvaluationArgs = {
+  claim: WarrantyClaim
+  lines: WarrantyClaimLine[]
+  settings: WarrantyClaimEffectiveSettings
+  risk: ClaimRiskAssessment
+  em: EntityManager
+  scope: { tenantId: string; organizationId: string }
+  data: BusinessRulesClaimData
+}
+
+type BusinessRulesExecutionContext = {
+  entityType: string
+  entityId: string
+  eventType: string
+  data: BusinessRulesClaimData
+  tenantId: string
+  organizationId: string
+  dryRun: boolean
+}
+
+type BusinessRulesExecutionResult = {
+  allowed?: boolean
+  executedRules?: unknown[]
+  errors?: unknown[]
+}
+
+type BusinessRulesServiceLike = {
+  evaluateWarrantyClaim?: (args: BusinessRulesClaimEvaluationArgs) => Promise<unknown>
+  evaluate?: (args: BusinessRulesClaimEvaluationArgs) => Promise<unknown>
+  executeRules?: (em: EntityManager, context: BusinessRulesExecutionContext) => Promise<BusinessRulesExecutionResult>
+}
+
+type LightDecisionEvaluation = {
+  eligible: boolean
+  facts: Record<string, unknown>
+}
+
+type BusinessRulesEvaluation =
+  | { kind: 'unavailable' }
+  | { kind: 'decision'; value: WarrantyAdjudicationDecision }
+
+function numericAmount(value: string | number | null | undefined): number {
+  if (value === null || value === undefined) return 0
+  const parsed = typeof value === 'number' ? value : Number(value)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
+}
+
+function readDecision(value: unknown): WarrantyAdjudicationDecision['decision'] | null {
+  return value === 'auto_approve' || value === 'manual_review' ? value : null
+}
+
+function buildBusinessRulesData(args: {
+  claim: WarrantyClaim
+  lines: WarrantyClaimLine[]
+  settings: WarrantyClaimEffectiveSettings
+  risk: ClaimRiskAssessment
+}): BusinessRulesClaimData {
+  return {
+    claim: {
+      id: args.claim.id,
+      claimType: args.claim.claimType,
+      status: args.claim.status,
+      currencyCode: args.claim.currencyCode ?? null,
+      totalClaimedAmount: numericAmount(args.claim.totalClaimedAmount),
+      customerId: args.claim.customerId ?? null,
+      orderId: args.claim.orderId ?? null,
+      reasonCode: args.claim.reasonCode ?? null,
+    },
+    lines: args.lines.map((line) => ({
+      id: line.id,
+      warrantyStatus: line.warrantyStatus,
+      lineStatus: line.lineStatus,
+      qtyClaimed: numericAmount(line.qtyClaimed),
+      creditAmount: numericAmount(line.creditAmount),
+      disposition: line.disposition ?? null,
+      conditionGrade: line.conditionGrade ?? null,
+      quarantineStatus: line.quarantineStatus,
+    })),
+    settings: {
+      autoApproveEnabled: args.settings.autoApproveEnabled,
+      autoApproveMaxAmount: args.settings.autoApproveMaxAmount,
+      autoApproveCurrencyCode: args.settings.autoApproveCurrencyCode,
+      autoApproveRequireInWarranty: args.settings.autoApproveRequireInWarranty,
+      adjudicationUseRules: args.settings.adjudicationUseRules,
+    },
+    risk: args.risk,
+  }
+}
+
+function evaluateLightEligibility(args: {
+  claim: WarrantyClaim
+  lines: WarrantyClaimLine[]
+  settings: WarrantyClaimEffectiveSettings
+  risk: ClaimRiskAssessment
+}): LightDecisionEvaluation {
+  const currencyCode = args.claim.currencyCode ?? null
+  const hasLimit = args.settings.autoApproveMaxAmount !== null && args.settings.autoApproveCurrencyCode !== null
+  const currencyMatches = currencyCode === args.settings.autoApproveCurrencyCode
+  // A zero/indeterminate claimed amount must NOT satisfy the cap — a valuable claim whose
+  // value has not been entered yet would otherwise auto-approve as though it were worth 0
+  // (WQA-009). Require a positive claimed amount so undetermined value routes to manual review.
+  const claimedAmount = numericAmount(args.claim.totalClaimedAmount)
+  const amountWithinLimit = args.settings.autoApproveMaxAmount !== null
+    && claimedAmount > 0
+    && claimedAmount <= args.settings.autoApproveMaxAmount
+  const warrantyRequirementSatisfied = !args.settings.autoApproveRequireInWarranty
+    || args.lines.every((line) => line.warrantyStatus === 'in_warranty')
+  const eligible = args.settings.autoApproveEnabled
+    && hasLimit
+    && args.lines.length > 0
+    && currencyMatches
+    && amountWithinLimit
+    && warrantyRequirementSatisfied
+    && args.risk.signals.length === 0
+
+  return {
+    eligible,
+    facts: {
+      rule: 'light',
+      mode: 'light',
+      autoApproveEligible: eligible,
+      forcedManualByRisk: false,
+      autoApproveEnabled: args.settings.autoApproveEnabled,
+      hasLimit,
+      lineCount: args.lines.length,
+      currencyMatches,
+      amountWithinLimit,
+      warrantyRequirementSatisfied,
+      riskLevel: args.risk.level,
+      riskSignalCount: args.risk.signals.length,
+    },
+  }
+}
+
+function lightDecision(args: {
+  claim: WarrantyClaim
+  lines: WarrantyClaimLine[]
+  settings: WarrantyClaimEffectiveSettings
+  risk: ClaimRiskAssessment
+}): WarrantyAdjudicationDecision {
+  const light = evaluateLightEligibility(args)
+  return {
+    decision: light.eligible ? 'auto_approve' : 'manual_review',
+    facts: light.facts,
+  }
+}
+
+function businessRulesDecision(
+  decision: WarrantyAdjudicationDecision['decision'],
+  risk: ClaimRiskAssessment,
+  facts: Record<string, unknown>,
+): WarrantyAdjudicationDecision {
+  return {
+    decision,
+    facts: {
+      rule: 'business_rules',
+      mode: 'business_rules',
+      delegated: true,
+      autoApproveEligible: decision === 'auto_approve',
+      forcedManualByRisk: false,
+      riskLevel: risk.level,
+      riskSignalCount: risk.signals.length,
+      ...facts,
+    },
+  }
+}
+
+function parseBusinessRulesDecision(value: unknown, risk: ClaimRiskAssessment): WarrantyAdjudicationDecision | null {
+  if (!isRecord(value)) return null
+
+  const directDecision = readDecision(value.decision)
+  if (directDecision) {
+    return businessRulesDecision(directDecision, risk, {})
+  }
+
+  const nestedResult = isRecord(value.result) ? value.result : null
+  const nestedDecision = nestedResult ? readDecision(nestedResult.decision) : null
+  if (nestedDecision) {
+    return businessRulesDecision(nestedDecision, risk, {})
+  }
+
+  const allowed = typeof value.allowed === 'boolean'
+    ? value.allowed
+    : nestedResult && typeof nestedResult.allowed === 'boolean'
+      ? nestedResult.allowed
+      : null
+  if (allowed === null) return null
+
+  const executedRules = Array.isArray(value.executedRules)
+    ? value.executedRules
+    : nestedResult && Array.isArray(nestedResult.executedRules)
+      ? nestedResult.executedRules
+      : null
+  if (executedRules && executedRules.length === 0) return null
+
+  const errors = Array.isArray(value.errors)
+    ? value.errors
+    : nestedResult && Array.isArray(nestedResult.errors)
+      ? nestedResult.errors
+      : []
+
+  if (errors.length > 0) {
+    return businessRulesDecision('manual_review', risk, {
+      allowed,
+      executedRuleCount: executedRules?.length ?? null,
+      errorCount: errors.length,
+      failureReason: 'rule_errors',
+    })
+  }
+
+  return businessRulesDecision(allowed ? 'auto_approve' : 'manual_review', risk, {
+    allowed,
+    executedRuleCount: executedRules?.length ?? null,
+    errorCount: errors.length,
+  })
+}
+
+async function evaluateWithBusinessRules(args: {
+  claim: WarrantyClaim
+  lines: WarrantyClaimLine[]
+  settings: WarrantyClaimEffectiveSettings
+  risk: ClaimRiskAssessment
+  container: { resolve: <R = unknown>(n: string) => R }
+  em: EntityManager
+  scope: { tenantId: string; organizationId: string }
+}): Promise<BusinessRulesEvaluation> {
+  const service = tryResolve<BusinessRulesServiceLike>(args.container, 'businessRulesService')
+    ?? tryResolve<BusinessRulesServiceLike>(args.container, 'ruleEngine')
+  if (!service) return { kind: 'unavailable' }
+
+  const data = buildBusinessRulesData(args)
+  const serviceArgs: BusinessRulesClaimEvaluationArgs = {
+    claim: args.claim,
+    lines: args.lines,
+    settings: args.settings,
+    risk: args.risk,
+    em: args.em,
+    scope: args.scope,
+    data,
+  }
+
+  if (typeof service.evaluateWarrantyClaim === 'function') {
+    const value = parseBusinessRulesDecision(await service.evaluateWarrantyClaim(serviceArgs), args.risk)
+    return {
+      kind: 'decision',
+      value: value ?? businessRulesDecision('manual_review', args.risk, { failureReason: 'invalid_result' }),
+    }
+  }
+
+  if (typeof service.evaluate === 'function') {
+    const value = parseBusinessRulesDecision(await service.evaluate(serviceArgs), args.risk)
+    return {
+      kind: 'decision',
+      value: value ?? businessRulesDecision('manual_review', args.risk, { failureReason: 'invalid_result' }),
+    }
+  }
+
+  if (typeof service.executeRules === 'function') {
+    const value = parseBusinessRulesDecision(await service.executeRules(args.em, {
+      entityType: 'warranty_claims:claim',
+      entityId: args.claim.id,
+      eventType: 'warranty_claims.claim.adjudicate',
+      data,
+      tenantId: args.scope.tenantId,
+      organizationId: args.scope.organizationId,
+      dryRun: true,
+    }), args.risk)
+    return {
+      kind: 'decision',
+      value: value ?? businessRulesDecision('manual_review', args.risk, { failureReason: 'invalid_result' }),
+    }
+  }
+
+  return {
+    kind: 'decision',
+    value: businessRulesDecision('manual_review', args.risk, { failureReason: 'unsupported_service' }),
+  }
+}
+
+export function createWarrantyAdjudicationEvaluator(): WarrantyAdjudicationEvaluator {
+  return {
+    async evaluate(args) {
+      if (args.risk.level === 'high') {
+        const light = evaluateLightEligibility(args)
+        return {
+          decision: 'manual_review',
+          facts: {
+            ...light.facts,
+            riskLevel: args.risk.level,
+            riskSignalCount: args.risk.signals.length,
+            forcedManualByRisk: true,
+          },
+        }
+      }
+
+      if (args.settings.adjudicationUseRules) {
+        try {
+          const evaluation = await evaluateWithBusinessRules(args)
+          if (evaluation.kind === 'decision') return evaluation.value
+        } catch {
+          return businessRulesDecision('manual_review', args.risk, {
+            failureReason: 'execution_failed',
+          })
+        }
+      }
+
+      return lightDecision(args)
+    },
+  }
+}

package/src/modules/warranty_claims/services/claimNumberGenerator.ts

@@ -0,0 +1,69 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { CLAIM_NUMBER_PREFIXES } from '../data/constants'
+import type { WarrantyClaimType } from '../data/validators'
+import { WarrantyClaimSequence } from '../data/entities'
+
+type Scope = {
+  organizationId: string
+  tenantId: string
+}
+
+type GenerateParams = Scope & {
+  claimType: WarrantyClaimType
+}
+
+const MAX_SEQUENCE = 1_000_000_000
+const DEFAULT_SEQUENCE_START = 1
+
+export class WarrantyClaimNumberGenerator {
+  constructor(private readonly em: EntityManager) {}
+
+  async peekNextSequence(claimType: WarrantyClaimType, scope: Scope): Promise<number> {
+    const record = await this.em.findOne(WarrantyClaimSequence, {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      claimType,
+    })
+    const nextNumber = typeof record?.nextNumber === 'number' ? record.nextNumber : DEFAULT_SEQUENCE_START
+    return Math.min(Math.max(nextNumber, DEFAULT_SEQUENCE_START), MAX_SEQUENCE)
+  }
+
+  async setNextSequence(claimType: WarrantyClaimType, scope: Scope, nextValue: number): Promise<void> {
+    const next = Math.min(Math.max(Math.floor(nextValue), DEFAULT_SEQUENCE_START), MAX_SEQUENCE)
+    await this.em.getConnection().execute(
+      `
+        insert into warranty_claim_sequences (id, organization_id, tenant_id, claim_type, next_number, created_at, updated_at)
+        values (gen_random_uuid(), ?, ?, ?, ?, now(), now())
+        on conflict (tenant_id, organization_id, claim_type)
+        do update set next_number = ?, updated_at = now()
+      `,
+      [scope.organizationId, scope.tenantId, claimType, next, next]
+    )
+  }
+
+  async generate(params: GenerateParams): Promise<{ number: string; prefix: string; sequence: number }> {
+    const sequence = await this.claimSequence(params.claimType, params)
+    const prefix = CLAIM_NUMBER_PREFIXES[params.claimType]
+    return {
+      number: `${prefix}-${String(sequence).padStart(6, '0')}`,
+      prefix,
+      sequence,
+    }
+  }
+
+  private async claimSequence(claimType: WarrantyClaimType, scope: Scope): Promise<number> {
+    const rows = await this.em.getConnection().execute<{ sequence: string }[]>(
+      `
+        insert into warranty_claim_sequences (id, organization_id, tenant_id, claim_type, next_number, created_at, updated_at)
+        values (gen_random_uuid(), ?, ?, ?, ?, now(), now())
+        on conflict (tenant_id, organization_id, claim_type)
+        do update set next_number = warranty_claim_sequences.next_number + 1, updated_at = now()
+        returning next_number - 1 as sequence
+      `,
+      [scope.organizationId, scope.tenantId, claimType, DEFAULT_SEQUENCE_START + 1]
+    )
+    const value = Number(rows?.[0]?.sequence ?? DEFAULT_SEQUENCE_START)
+    if (!Number.isFinite(value) || value < DEFAULT_SEQUENCE_START) return DEFAULT_SEQUENCE_START
+    return Math.min(value, MAX_SEQUENCE)
+  }
+}

package/src/modules/warranty_claims/services/entitlementResolver.ts

@@ -0,0 +1,102 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { WarrantyClaimRegistration } from '../data/entities'
+import { addWarrantyMonths, computeWarrantyEntitlementPreview } from '../lib/warrantyPreview'
+import { resolveEffectiveWarrantyClaimSettings } from '../lib/settings'
+
+export interface WarrantyEntitlementInput {
+  serialNumber?: string | null
+  orderId?: string | null
+  productId?: string | null
+  variantId?: string | null
+  sku?: string | null
+  purchaseDate?: string | null
+}
+
+export interface WarrantyEntitlementResult {
+  warrantyStatus: 'in_warranty' | 'out_of_warranty' | 'unknown'
+  coverageType: 'standard' | 'extended' | 'none' | null
+  expiresAt: string | null
+  source: 'registration' | 'order' | 'manual' | 'resolver' | null
+}
+
+export interface WarrantyEntitlementResolver {
+  resolveEntitlement(
+    input: WarrantyEntitlementInput,
+    scope: { tenantId: string; organizationId: string },
+    em: EntityManager,
+  ): Promise<WarrantyEntitlementResult>
+}
+
+const UNKNOWN_ENTITLEMENT: WarrantyEntitlementResult = {
+  warrantyStatus: 'unknown',
+  coverageType: null,
+  expiresAt: null,
+  source: null,
+}
+
+function parseDate(value: string | null | undefined): Date | null {
+  if (!value) return null
+  const date = new Date(value)
+  return Number.isNaN(date.getTime()) ? null : date
+}
+
+function toIso(value: Date | null | undefined): string | null {
+  return value ? value.toISOString() : null
+}
+
+function resolveStatusFromExpiry(expiresAt: Date | null | undefined, now = new Date()): WarrantyEntitlementResult['warrantyStatus'] {
+  if (!expiresAt || Number.isNaN(expiresAt.getTime())) return 'unknown'
+  return expiresAt.getTime() >= now.getTime() ? 'in_warranty' : 'out_of_warranty'
+}
+
+export function createWarrantyEntitlementResolver(): WarrantyEntitlementResolver {
+  return {
+    async resolveEntitlement(input, scope, em) {
+      const serialNumber = input.serialNumber?.trim()
+
+      if (serialNumber) {
+        const registration = await findOneWithDecryption(
+          em,
+          WarrantyClaimRegistration,
+          {
+            tenantId: scope.tenantId,
+            organizationId: scope.organizationId,
+            serialNumber,
+            deletedAt: null,
+          },
+          {},
+          scope,
+        )
+
+        if (registration) {
+          const registrationStatus = resolveStatusFromExpiry(registration.warrantyExpiresAt)
+          return {
+            warrantyStatus: registrationStatus,
+            coverageType: registration.coverageType ?? null,
+            // Never pair an indeterminate status with a concrete source/expiry (LINE-04).
+            expiresAt: registrationStatus === 'unknown' ? null : toIso(registration.warrantyExpiresAt),
+            source: registrationStatus === 'unknown' ? null : 'registration',
+          }
+        }
+      }
+
+      const purchaseDate = parseDate(input.purchaseDate)
+      if (!purchaseDate) return UNKNOWN_ENTITLEMENT
+
+      const settings = await resolveEffectiveWarrantyClaimSettings(em, scope)
+      const warrantyStatus = computeWarrantyEntitlementPreview(purchaseDate, settings.defaultWarrantyMonths)
+      const expiresAt = settings.defaultWarrantyMonths === null
+        ? null
+        : addWarrantyMonths(purchaseDate, settings.defaultWarrantyMonths)
+
+      return {
+        warrantyStatus,
+        coverageType: null,
+        // Never pair an indeterminate status with a concrete source/expiry (LINE-04).
+        expiresAt: warrantyStatus === 'unknown' ? null : toIso(expiresAt),
+        source: warrantyStatus === 'unknown' ? null : (input.orderId ? 'order' : 'resolver'),
+      }
+    },
+  }
+}

package/src/modules/warranty_claims/services/returnLabelProvider.ts

@@ -0,0 +1,30 @@
+import type { WarrantyClaim, WarrantyClaimLine } from '../data/entities'
+import { tryResolve } from '../lib/tryResolve'
+
+export type WarrantyReturnLabelResult =
+  | { status: 'created'; labelUrl: string; trackingNumber: string; carrier: string }
+  | { status: 'notConfigured' }
+
+export interface WarrantyReturnLabelProvider {
+  createReturnLabel(
+    input: { claim: WarrantyClaim; lines: WarrantyClaimLine[] },
+    scope: { tenantId: string; organizationId: string },
+    container: { resolve: <R = unknown>(n: string) => R },
+  ): Promise<WarrantyReturnLabelResult>
+}
+
+/**
+ * Default core provider. Enterprise or carrier packages override the
+ * `warrantyReturnLabelProvider` DI key with concrete label generation.
+ */
+export function createWarrantyReturnLabelProvider(): WarrantyReturnLabelProvider {
+  return {
+    async createReturnLabel(_input, _scope, container) {
+      const shippingCarrierService = tryResolve<unknown>(container, 'shippingCarrierService')
+      if (!shippingCarrierService) return { status: 'notConfigured' }
+
+      // Carrier packages can transition awaiting_return -> received via the existing transition command on delivery scan.
+      return { status: 'notConfigured' }
+    },
+  }
+}

package/src/modules/warranty_claims/setup.ts

@@ -0,0 +1,154 @@
+import { createHash } from 'node:crypto'
+import type { ModuleSetupConfig } from '@open-mercato/shared/modules/setup'
+import { CLAIM_TYPES } from './data/validators'
+import { WarrantyClaimSequence } from './data/entities'
+import { seedWarrantyClaimDictionaries } from './lib/dictionaries'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('warranty_claims')
+
+type SchedulerServiceLike = {
+  register: (registration: {
+    id: string
+    name: string
+    scopeType: 'system' | 'organization' | 'tenant'
+    organizationId?: string
+    tenantId?: string
+    scheduleType: 'cron' | 'interval'
+    scheduleValue: string
+    timezone?: string
+    targetType: 'queue' | 'command'
+    targetQueue?: string
+    targetPayload?: unknown
+    sourceType?: 'user' | 'module'
+    sourceModule?: string
+    isEnabled?: boolean
+    description?: string
+  }) => Promise<void>
+}
+
+// Cross-module READ grants the desk genuinely needs: the intake order picker and
+// the product picker call the sales and catalog list APIs directly. Assignee names
+// are resolved through this module's own `warranty_claims.claim.view`-gated
+// `/api/warranty_claims/assignees` endpoint, so no `auth.*` grant is required here —
+// granting one would hand every role that can see a claim the tenant's full user
+// directory, including emails and role assignments.
+const connectedIntakeFeatures = ['sales.orders.view', 'catalog.products.view']
+
+const adminFeatures = [
+  'warranty_claims.*',
+  'warranty_claims.claim.view',
+  'warranty_claims.claim.create',
+  'warranty_claims.claim.manage',
+  'warranty_claims.claim.delete',
+  'warranty_claims.settings.manage',
+  'warranty_claims.external.submit',
+  'warranty_claims.external.view',
+  'warranty_claims.registration.view',
+  'warranty_claims.registration.manage',
+  'warranty_claims.vendor_policy.manage',
+  'warranty_claims.troubleshooting.manage',
+  'warranty_claims.receiving.manage',
+  ...connectedIntakeFeatures,
+]
+
+const ownerFeatures = [
+  'warranty_claims.*',
+  'warranty_claims.claim.view',
+  'warranty_claims.claim.create',
+  'warranty_claims.claim.manage',
+  'warranty_claims.claim.delete',
+  'warranty_claims.settings.manage',
+  'warranty_claims.registration.view',
+  'warranty_claims.registration.manage',
+  'warranty_claims.vendor_policy.manage',
+  'warranty_claims.troubleshooting.manage',
+  'warranty_claims.receiving.manage',
+  ...connectedIntakeFeatures,
+]
+
+function stableScheduleUuid(stableKey: string): string {
+  const hex = createHash('sha256').update(stableKey).digest('hex')
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`
+}
+
+function stableSlaSweepScheduleId(organizationId: string): string {
+  return stableScheduleUuid(`warranty_claims:sla-sweep:${organizationId}`)
+}
+
+export const setup: ModuleSetupConfig = {
+  defaultRoleFeatures: {
+    admin: adminFeatures,
+    owner: ownerFeatures,
+    employee: [
+      'warranty_claims.claim.view',
+      'warranty_claims.claim.create',
+      'warranty_claims.claim.manage',
+      'warranty_claims.registration.view',
+      'warranty_claims.registration.manage',
+      'warranty_claims.receiving.manage',
+      ...connectedIntakeFeatures,
+    ],
+  },
+
+  async onTenantCreated({ em, tenantId, organizationId }) {
+    const now = new Date()
+    for (const claimType of CLAIM_TYPES) {
+      const sequence = await em.findOne(WarrantyClaimSequence, {
+        tenantId,
+        organizationId,
+        claimType,
+      })
+      if (!sequence) {
+        em.persist(
+          em.create(WarrantyClaimSequence, {
+            tenantId,
+            organizationId,
+            claimType,
+            nextNumber: 1,
+            createdAt: now,
+            updatedAt: now,
+          })
+        )
+      }
+    }
+    await em.flush()
+  },
+
+  async seedDefaults({ em, tenantId, organizationId, container }) {
+    await seedWarrantyClaimDictionaries(em, { tenantId, organizationId })
+    const cradle = container as { hasRegistration?: (name: string) => boolean }
+    if (typeof cradle.hasRegistration !== 'function' || !cradle.hasRegistration('schedulerService')) {
+      return
+    }
+
+    const schedulerService = container.resolve('schedulerService') as SchedulerServiceLike
+    try {
+      await schedulerService.register({
+        id: stableSlaSweepScheduleId(organizationId),
+        name: 'Warranty claims SLA sweep',
+        description: 'Enqueues tenant-scoped warranty claim SLA escalation sweeps every 900 seconds.',
+        scopeType: 'organization',
+        organizationId,
+        tenantId,
+        scheduleType: 'interval',
+        scheduleValue: '900s',
+        timezone: 'UTC',
+        targetType: 'queue',
+        targetQueue: 'warranty_claims.sla_sweep',
+        targetPayload: {
+          scope: { tenantId, organizationId },
+        },
+        sourceType: 'module',
+        sourceModule: 'warranty_claims',
+        isEnabled: true,
+      })
+    } catch (error) {
+      logger.warn('[warranty_claims] Failed to register SLA sweep schedule', {
+        error: error instanceof Error ? error.message : error,
+      })
+    }
+  },
+}
+
+export default setup