@open-mercato/core 0.4.2-canary-c71ef83148 → 0.4.2-canary-f821f89ef6

package/src/modules/business_rules/index.ts

@@ -8,3 +8,28 @@ export const metadata: ModuleInfo = {
   author: 'Patryk Lewczuk',
   license: 'Proprietary',
 }
+
+// Export rule engine types and functions for programmatic usage
+export {
+  executeRules,
+  executeRuleById,
+  executeRuleByRuleId,
+  executeSingleRule,
+  findApplicableRules,
+  logRuleExecution,
+  type RuleEngineContext,
+  type RuleEngineResult,
+  type RuleExecutionResult,
+  type RuleDiscoveryOptions,
+  type DirectRuleExecutionContext,
+  type DirectRuleExecutionResult,
+  type RuleIdExecutionContext,
+} from './lib/rule-engine'
+
+// Export validator schemas
+export {
+  directRuleExecutionContextSchema,
+  ruleIdExecutionContextSchema,
+  type DirectRuleExecutionContextInput,
+  type RuleIdExecutionContextInput,
+} from './data/validators'

package/src/modules/business_rules/lib/__tests__/rule-engine.test.ts

@@ -654,57 +654,6 @@ describe('Rule Engine (Unit Tests)', () => {
       expect(result.errors).toBeDefined()
       expect(result.errors![0]).toContain('Rule count limit exceeded')
     })
-
-    test('should emit execution_failed event when rule evaluation fails', async () => {
-      const mockRule: Partial<BusinessRule> = {
-        id: 'rule-1',
-        ruleId: 'TEST-001',
-        ruleName: 'Test Rule',
-        ruleType: 'ACTION',
-        entityType: 'WorkOrder',
-        conditionExpression: { field: 'status', operator: '=', value: 'RELEASED' },
-        enabled: true,
-        tenantId: testTenantId,
-        organizationId: testOrgId,
-      }
-
-      mockEm.find.mockResolvedValue([mockRule as BusinessRule])
-      mockEm.create.mockReturnValue({ id: 'log-1' } as any)
-      mockEm.persistAndFlush.mockResolvedValue(undefined)
-
-      jest.mocked(ruleEvaluator.evaluateSingleRule).mockResolvedValue({
-        rule: mockRule as BusinessRule,
-        conditionsPassed: false,
-        evaluationCompleted: false,
-        evaluationTime: 1,
-        error: 'Evaluation error',
-      })
-
-      const eventBus = { emitEvent: jest.fn().mockResolvedValue(undefined) }
-
-      const context: RuleEngineContext = {
-        entityType: 'WorkOrder',
-        entityId: testEntityId,
-        data: { status: 'RELEASED' },
-        tenantId: testTenantId,
-        organizationId: testOrgId,
-        dryRun: false,
-      }
-
-      await ruleEngine.executeRules(mockEm, context, { eventBus })
-
-      expect(eventBus.emitEvent).toHaveBeenCalledWith(
-        'business_rules.rule.execution_failed',
-        expect.objectContaining({
-          ruleId: 'TEST-001',
-          ruleName: 'Test Rule',
-          entityType: 'WorkOrder',
-          errorMessage: 'Evaluation error',
-          tenantId: testTenantId,
-          organizationId: testOrgId,
-        })
-      )
-    })
   })
 
   describe('logRuleExecution', () => {

package/src/modules/business_rules/lib/rule-engine.ts

@@ -1,11 +1,10 @@
 import type { EntityManager } from '@mikro-orm/core'
-import type { EventBus } from '@open-mercato/events'
 import { BusinessRule, RuleExecutionLog, type RuleType } from '../data/entities'
 import * as ruleEvaluator from './rule-evaluator'
 import * as actionExecutor from './action-executor'
 import type { RuleEvaluationContext } from './rule-evaluator'
 import type { ActionContext, ActionExecutionOutcome } from './action-executor'
-import { ruleEngineContextSchema, ruleDiscoveryOptionsSchema } from '../data/validators'
+import { ruleEngineContextSchema, ruleDiscoveryOptionsSchema, directRuleExecutionContextSchema, ruleIdExecutionContextSchema } from '../data/validators'
 
 /**
  * Constants
@@ -86,17 +85,63 @@ export interface RuleDiscoveryOptions {
   ruleType?: RuleType
 }
 
-export type RuleEngineExecutionOptions = {
-  eventBus?: Pick<EventBus, 'emitEvent'> | null
+/**
+ * Direct rule execution context (for executing a specific rule by ID)
+ */
+export interface DirectRuleExecutionContext {
+  ruleId: string  // Database UUID of the rule
+  data: any
+  user?: {
+    id?: string
+    email?: string
+    role?: string
+    [key: string]: any
+  }
+  tenantId: string
+  organizationId: string
+  executedBy?: string
+  dryRun?: boolean
+  // Optional for logging (falls back to rule's entityType)
+  entityType?: string
+  entityId?: string
+  eventType?: string
 }
 
-type RuleExecutionFailedPayload = {
+/**
+ * Direct rule execution result
+ */
+export interface DirectRuleExecutionResult {
+  success: boolean
   ruleId: string
   ruleName: string
-  entityType?: string | null
-  errorMessage?: string | null
+  conditionResult: boolean
+  actionsExecuted: ActionExecutionOutcome | null
+  executionTime: number
+  error?: string
+  logId?: string
+}
+
+/**
+ * Context for executing a rule by its string rule_id identifier
+ * Unlike DirectRuleExecutionContext which uses database UUID,
+ * this uses the string identifier (e.g., "workflow_checkout_inventory_available")
+ */
+export interface RuleIdExecutionContext {
+  ruleId: string  // String identifier (e.g., "workflow_checkout_inventory_available")
+  data: any
+  user?: {
+    id?: string
+    email?: string
+    role?: string
+    [key: string]: any
+  }
   tenantId: string
-  organizationId?: string | null
+  organizationId: string
+  executedBy?: string
+  dryRun?: boolean
+  entityType?: string
+  entityId?: string
+  eventType?: string
 }
 
 /**
@@ -127,8 +172,7 @@ async function withTimeout<T>(
  */
 export async function executeRules(
   em: EntityManager,
-  context: RuleEngineContext,
-  options: RuleEngineExecutionOptions = {}
+  context: RuleEngineContext
 ): Promise<RuleEngineResult> {
   // Validate input
   const validation = ruleEngineContextSchema.safeParse(context)
@@ -174,7 +218,7 @@ export async function executeRules(
     const executionPromise = (async () => {
       for (const rule of rules) {
       try {
-        const ruleResult = await executeSingleRule(em, rule, context, options)
+        const ruleResult = await executeSingleRule(em, rule, context)
         executedRules.push(ruleResult)
 
         if (ruleResult.logId) {
@@ -192,17 +236,6 @@ export async function executeRules(
           `Unexpected error in rule execution [ruleId=${rule.ruleId}, type=${rule.ruleType}]: ${errorMessage}`
         )
 
-        if (!context.dryRun) {
-          await emitRuleExecutionFailed(options.eventBus, {
-            ruleId: rule.ruleId,
-            ruleName: rule.ruleName,
-            entityType: context.entityType ?? null,
-            errorMessage,
-            tenantId: context.tenantId,
-            organizationId: context.organizationId ?? null,
-          })
-        }
-
         executedRules.push({
           rule,
           conditionResult: false,
@@ -259,8 +292,7 @@ export async function executeRules(
 export async function executeSingleRule(
   em: EntityManager,
   rule: BusinessRule,
-  context: RuleEngineContext,
-  options: RuleEngineExecutionOptions = {}
+  context: RuleEngineContext
 ): Promise<RuleExecutionResult> {
   const startTime = Date.now()
 
@@ -296,15 +328,6 @@ export async function executeSingleRule(
             executionTime,
             error: result.error,
           })
-
-          await emitRuleExecutionFailed(options.eventBus, {
-            ruleId: rule.ruleId,
-            ruleName: rule.ruleName,
-            entityType: context.entityType ?? null,
-            errorMessage: result.error ?? null,
-            tenantId: context.tenantId,
-            organizationId: context.organizationId ?? null,
-          })
         }
 
         return {
@@ -382,15 +405,6 @@ export async function executeSingleRule(
         executionTime,
         error: enhancedError,
       })
-
-      await emitRuleExecutionFailed(options.eventBus, {
-        ruleId: rule.ruleId,
-        ruleName: rule.ruleName,
-        entityType: context.entityType ?? null,
-        errorMessage: enhancedError,
-        tenantId: context.tenantId,
-        organizationId: context.organizationId ?? null,
-      })
     }
 
     return {
@@ -449,6 +463,227 @@ export async function findApplicableRules(
   })
 }
 
+/**
+ * Execute a specific rule by its database UUID
+ * This bypasses the entityType/eventType discovery mechanism and directly executes the rule
+ */
+export async function executeRuleById(
+  em: EntityManager,
+  context: DirectRuleExecutionContext
+): Promise<DirectRuleExecutionResult> {
+  const startTime = Date.now()
+
+  // Validate input
+  const validation = directRuleExecutionContextSchema.safeParse(context)
+  if (!validation.success) {
+    const validationErrors = validation.error.issues.map(e => `${e.path.join('.')}: ${e.message}`)
+    return {
+      success: false,
+      ruleId: context.ruleId,
+      ruleName: 'Unknown',
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: `Validation failed: ${validationErrors.join(', ')}`,
+    }
+  }
+
+  // Fetch rule by ID with tenant/org validation
+  const rule = await em.findOne(BusinessRule, {
+    id: context.ruleId,
+    tenantId: context.tenantId,
+    organizationId: context.organizationId,
+    deletedAt: null,
+  })
+
+  if (!rule) {
+    return {
+      success: false,
+      ruleId: context.ruleId,
+      ruleName: 'Unknown',
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: 'Rule not found',
+    }
+  }
+
+  if (!rule.enabled) {
+    return {
+      success: false,
+      ruleId: rule.ruleId,
+      ruleName: rule.ruleName,
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: 'Rule is disabled',
+    }
+  }
+
+  // Check effective date range
+  const now = new Date()
+  if (rule.effectiveFrom && rule.effectiveFrom > now) {
+    return {
+      success: false,
+      ruleId: rule.ruleId,
+      ruleName: rule.ruleName,
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: `Rule is not yet effective (starts ${rule.effectiveFrom.toISOString()})`,
+    }
+  }
+  if (rule.effectiveTo && rule.effectiveTo < now) {
+    return {
+      success: false,
+      ruleId: rule.ruleId,
+      ruleName: rule.ruleName,
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: `Rule has expired (ended ${rule.effectiveTo.toISOString()})`,
+    }
+  }
+
+  // Build RuleEngineContext (use provided entityType or fall back to rule's)
+  const engineContext: RuleEngineContext = {
+    entityType: context.entityType || rule.entityType,
+    entityId: context.entityId,
+    eventType: context.eventType || rule.eventType || undefined,
+    data: context.data,
+    user: context.user,
+    tenantId: context.tenantId,
+    organizationId: context.organizationId,
+    executedBy: context.executedBy,
+    dryRun: context.dryRun,
+  }
+
+  // Execute via existing executeSingleRule
+  const result = await executeSingleRule(em, rule, engineContext)
+
+  return {
+    success: !result.error,
+    ruleId: rule.ruleId,
+    ruleName: rule.ruleName,
+    conditionResult: result.conditionResult,
+    actionsExecuted: result.actionsExecuted,
+    executionTime: result.executionTime,
+    error: result.error,
+    logId: result.logId,
+  }
+}
+
+/**
+ * Execute a rule by its string rule_id identifier
+ * Looks up rule by rule_id (string column) + tenant_id (unique constraint)
+ * This is useful for workflow conditions that reference rules by their string identifiers
+ */
+export async function executeRuleByRuleId(
+  em: EntityManager,
+  context: RuleIdExecutionContext
+): Promise<DirectRuleExecutionResult> {
+  const startTime = Date.now()
+
+  // Validate input
+  const validation = ruleIdExecutionContextSchema.safeParse(context)
+  if (!validation.success) {
+    const validationErrors = validation.error.issues.map(e => `${e.path.join('.')}: ${e.message}`)
+    return {
+      success: false,
+      ruleId: context.ruleId || 'unknown',
+      ruleName: 'Unknown',
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: `Validation failed: ${validationErrors.join(', ')}`,
+    }
+  }
+
+  // Fetch rule by rule_id (string identifier) + tenant/org
+  const rule = await em.findOne(BusinessRule, {
+    ruleId: context.ruleId,  // String identifier column
+    tenantId: context.tenantId,
+    organizationId: context.organizationId,
+    deletedAt: null,
+  })
+
+  if (!rule) {
+    return {
+      success: false,
+      ruleId: context.ruleId,
+      ruleName: 'Unknown',
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: 'Rule not found',
+    }
+  }
+
+  if (!rule.enabled) {
+    return {
+      success: false,
+      ruleId: rule.ruleId,
+      ruleName: rule.ruleName,
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: 'Rule is disabled',
+    }
+  }
+
+  // Check effective date range
+  const now = new Date()
+  if (rule.effectiveFrom && rule.effectiveFrom > now) {
+    return {
+      success: false,
+      ruleId: rule.ruleId,
+      ruleName: rule.ruleName,
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: `Rule is not yet effective (starts ${rule.effectiveFrom.toISOString()})`,
+    }
+  }
+  if (rule.effectiveTo && rule.effectiveTo < now) {
+    return {
+      success: false,
+      ruleId: rule.ruleId,
+      ruleName: rule.ruleName,
+      conditionResult: false,
+      actionsExecuted: null,
+      executionTime: Date.now() - startTime,
+      error: `Rule has expired (ended ${rule.effectiveTo.toISOString()})`,
+    }
+  }
+
+  // Build RuleEngineContext (use provided entityType or fall back to rule's)
+  const engineContext: RuleEngineContext = {
+    entityType: context.entityType || rule.entityType,
+    entityId: context.entityId,
+    eventType: context.eventType || rule.eventType || undefined,
+    data: context.data,
+    user: context.user,
+    tenantId: context.tenantId,
+    organizationId: context.organizationId,
+    executedBy: context.executedBy,
+    dryRun: context.dryRun,
+  }
+
+  // Execute via existing executeSingleRule
+  const result = await executeSingleRule(em, rule, engineContext)
+
+  return {
+    success: !result.error,
+    ruleId: rule.ruleId,
+    ruleName: rule.ruleName,
+    conditionResult: result.conditionResult,
+    actionsExecuted: result.actionsExecuted,
+    executionTime: result.executionTime,
+    error: result.error,
+    logId: result.logId,
+  }
+}
+
 /**
  * Sensitive field patterns to exclude from logs
  */
@@ -589,12 +824,3 @@ export async function logRuleExecution(
 
   return log.id
 }
-
-async function emitRuleExecutionFailed(
-  eventBus: Pick<EventBus, 'emitEvent'> | null | undefined,
-  payload: RuleExecutionFailedPayload
-): Promise<void> {
-  if (!eventBus?.emitEvent) return
-
-  await eventBus.emitEvent('business_rules.rule.execution_failed', payload).catch(() => undefined)
-}

package/src/modules/catalog/components/PriceKindSettings.tsx

@@ -420,12 +420,10 @@ export function PriceKindSettings() {
             <RowActions
               items={[
                 {
-                  id: 'edit',
                   label: t('catalog.priceKinds.actions.edit', 'Edit'),
                   onSelect: () => openDialog({ mode: 'edit', entry }),
                 },
                 {
-                  id: 'delete',
                   label: t('catalog.priceKinds.actions.delete', 'Delete'),
                   destructive: true,
                   onSelect: () => { void handleDelete(entry) },

package/src/modules/catalog/components/categories/CategoriesDataTable.tsx

@@ -221,8 +221,8 @@ export default function CategoriesDataTable() {
         canManage ? (
           <RowActions
             items={[
-              { id: 'edit', label: t('catalog.categories.list.actions.edit', 'Edit'), href: `/backend/catalog/categories/${row.id}/edit` },
-              { id: 'delete', label: t('catalog.categories.list.actions.delete', 'Delete'), destructive: true, onSelect: () => handleDelete(row) },
+              { label: t('catalog.categories.list.actions.edit', 'Edit'), href: `/backend/catalog/categories/${row.id}/edit` },
+              { label: t('catalog.categories.list.actions.delete', 'Delete'), destructive: true, onSelect: () => handleDelete(row) },
             ]}
           />
         ) : null

package/src/modules/catalog/components/products/ProductsDataTable.tsx

@@ -650,12 +650,10 @@ export default function ProductsDataTable() {
         <RowActions
           items={[
             {
-              id: 'edit',
               label: t('catalog.products.table.actions.edit', 'Edit'),
               href: `/backend/catalog/products/${row.id}`,
             },
             {
-              id: 'delete',
               label: t('catalog.products.table.actions.delete', 'Delete'),
               destructive: true,
               onSelect: () => {

package/src/modules/catalog/events.ts

@@ -0,0 +1,45 @@
+import { createModuleEvents } from '@open-mercato/shared/modules/events'
+
+/**
+ * Catalog Module Events
+ *
+ * Declares all events that can be emitted by the catalog module.
+ */
+const events = [
+  // Products
+  { id: 'catalog.product.created', label: 'Product Created', entity: 'product', category: 'crud' },
+  { id: 'catalog.product.updated', label: 'Product Updated', entity: 'product', category: 'crud' },
+  { id: 'catalog.product.deleted', label: 'Product Deleted', entity: 'product', category: 'crud' },
+
+  // Categories
+  { id: 'catalog.category.created', label: 'Category Created', entity: 'category', category: 'crud' },
+  { id: 'catalog.category.updated', label: 'Category Updated', entity: 'category', category: 'crud' },
+  { id: 'catalog.category.deleted', label: 'Category Deleted', entity: 'category', category: 'crud' },
+
+  // Variants
+  { id: 'catalog.variant.created', label: 'Variant Created', entity: 'variant', category: 'crud' },
+  { id: 'catalog.variant.updated', label: 'Variant Updated', entity: 'variant', category: 'crud' },
+  { id: 'catalog.variant.deleted', label: 'Variant Deleted', entity: 'variant', category: 'crud' },
+
+  // Prices
+  { id: 'catalog.price.created', label: 'Price Created', entity: 'price', category: 'crud' },
+  { id: 'catalog.price.updated', label: 'Price Updated', entity: 'price', category: 'crud' },
+  { id: 'catalog.price.deleted', label: 'Price Deleted', entity: 'price', category: 'crud' },
+
+  // Lifecycle events - Pricing resolution
+  { id: 'catalog.pricing.resolve.before', label: 'Before Pricing Resolve', category: 'lifecycle', excludeFromTriggers: true },
+  { id: 'catalog.pricing.resolve.after', label: 'After Pricing Resolve', category: 'lifecycle', excludeFromTriggers: true },
+] as const
+
+export const eventsConfig = createModuleEvents({
+  moduleId: 'catalog',
+  events,
+})
+
+/** Type-safe event emitter for catalog module */
+export const emitCatalogEvent = eventsConfig.emit
+
+/** Event IDs that can be emitted by the catalog module */
+export type CatalogEventId = typeof events[number]['id']
+
+export default eventsConfig

package/src/modules/catalog/i18n/en.json

@@ -681,7 +681,5 @@
         "deleteError": "Failed to delete variant."
       }
     }
-  },
-  "catalog.notifications.product.lowStock.title": "Low Stock Alert",
-  "catalog.notifications.product.lowStock.body": "{productName}{sku, select, other { ({sku})}} is running low on stock ({currentStock} remaining, threshold: {threshold})"
+  }
 }

package/src/modules/configs/cli.ts

@@ -2,7 +2,6 @@ import type { ModuleCli } from '@open-mercato/shared/modules/registry'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import type { ModuleConfigService } from './lib/module-config-service'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
-import { DEFAULT_NOTIFICATION_DELIVERY_CONFIG, NOTIFICATIONS_DELIVERY_CONFIG_KEY } from '../notifications/lib/deliveryConfig'
 
 function envDisablesAutoIndexing(): boolean {
   const raw = process.env.DISABLE_VECTOR_SEARCH_AUTOINDEXING
@@ -32,11 +31,6 @@ const restoreDefaults: ModuleCli = {
             name: 'auto_index_enabled',
             value: defaultEnabled,
           },
-          {
-            moduleId: 'notifications',
-            name: NOTIFICATIONS_DELIVERY_CONFIG_KEY,
-            value: DEFAULT_NOTIFICATION_DELIVERY_CONFIG,
-          },
         ],
         { force: true },
       )

package/src/modules/configs/components/CachePanel.tsx

@@ -194,7 +194,7 @@ export function CachePanel() {
         <header className="space-y-1">
           <h2 className="text-lg font-semibold">{t('configs.cache.title', 'Cache overview')}</h2>
           <p className="text-sm text-muted-foreground">
-            {t('configs.cache.description', 'Inspect cached responses and clear segments when necessary.')}
+            {t('configs.cache.description', 'Inspect cached CRUD responses and clear segments when necessary.')}
           </p>
         </header>
         <div className="flex items-center gap-2 text-sm text-muted-foreground">
@@ -211,7 +211,7 @@ export function CachePanel() {
         <header className="space-y-1">
           <h2 className="text-lg font-semibold">{t('configs.cache.title', 'Cache overview')}</h2>
           <p className="text-sm text-muted-foreground">
-            {t('configs.cache.description', 'Inspect cached responses and clear segments when necessary.')}
+            {t('configs.cache.description', 'Inspect cached CRUD responses and clear segments when necessary.')}
           </p>
         </header>
         <div className="rounded border border-red-200 bg-red-50 p-3 text-sm text-red-700">
@@ -235,7 +235,7 @@ export function CachePanel() {
         <div className="space-y-1">
           <h2 className="text-lg font-semibold">{t('configs.cache.title', 'Cache overview')}</h2>
           <p className="text-sm text-muted-foreground">
-            {t('configs.cache.description', 'Inspect cached responses and clear segments when necessary.')}
+            {t('configs.cache.description', 'Inspect cached CRUD responses and clear segments when necessary.')}
           </p>
           {stats ? (
             <>
@@ -342,7 +342,7 @@ export function CachePanel() {
           </div>
         ) : (
           <p className="text-sm text-muted-foreground">
-            {t('configs.cache.empty', 'No cached responses for this tenant.')}
+            {t('configs.cache.empty', 'No cached CRUD responses for this tenant.')}
           </p>
         )}
       </div>

package/src/modules/configs/i18n/en.json

@@ -35,14 +35,14 @@
   "configs.systemStatus.actions.purgeCacheUnavailable": "Cache service is unavailable.",
   "configs.config.nav.cache": "Cache",
   "configs.cache.title": "Cache overview",
-  "configs.cache.description": "Inspect cached responses and clear segments when necessary.",
+  "configs.cache.description": "Inspect cached CRUD responses and clear segments when necessary.",
   "configs.cache.loading": "Loading cache statistics…",
   "configs.cache.loadError": "Failed to load cache statistics.",
   "configs.cache.retry": "Retry",
   "configs.cache.refresh": "Refresh",
   "configs.cache.generatedAt": "Stats generated {{timestamp}}",
   "configs.cache.totalEntries": "{{count}} cached entries",
-  "configs.cache.empty": "No cached responses for this tenant.",
+  "configs.cache.empty": "No cached CRUD responses for this tenant.",
   "configs.cache.purgeAll": "Purge all cache",
   "configs.cache.purgeAllLoading": "Purging…",
   "configs.cache.purgeAllConfirm": "Purge all cached entries for this tenant?",
@@ -64,8 +64,6 @@
   "configs.systemStatus.categories.profilingDescription": "Flags that control request and query profiling outputs.",
   "configs.systemStatus.categories.logging": "Logging",
   "configs.systemStatus.categories.loggingDescription": "Tune verbosity and SQL logging for diagnostics.",
-  "configs.systemStatus.categories.security": "Security",
-  "configs.systemStatus.categories.securityDescription": "Password policy requirements enforced at login and user creation.",
   "configs.systemStatus.categories.caching": "Caching",
   "configs.systemStatus.categories.cachingDescription": "Cache providers and TTL controls for backend responses.",
   "configs.systemStatus.categories.queryIndex": "Query index",
@@ -86,14 +84,6 @@
   "configs.systemStatus.variables.logVerbosity.description": "Overrides structured log verbosity such as debug or trace.",
   "configs.systemStatus.variables.logLevel.label": "Log level",
   "configs.systemStatus.variables.logLevel.description": "Fallback log level applied when verbosity is not set.",
-  "configs.systemStatus.variables.passwordMinLength.label": "Password min length",
-  "configs.systemStatus.variables.passwordMinLength.description": "Minimum number of characters required for passwords.",
-  "configs.systemStatus.variables.passwordRequireDigit.label": "Password requires digit",
-  "configs.systemStatus.variables.passwordRequireDigit.description": "Require at least one numeric character.",
-  "configs.systemStatus.variables.passwordRequireUppercase.label": "Password requires uppercase",
-  "configs.systemStatus.variables.passwordRequireUppercase.description": "Require at least one uppercase letter.",
-  "configs.systemStatus.variables.passwordRequireSpecial.label": "Password requires special",
-  "configs.systemStatus.variables.passwordRequireSpecial.description": "Require at least one special character.",
   "configs.systemStatus.variables.enableCrudApiCache.label": "CRUD API cache",
   "configs.systemStatus.variables.enableCrudApiCache.description": "Enable the CRUD API response cache layer.",
   "configs.systemStatus.variables.cacheStrategy.label": "Cache strategy",