@open-mercato/core 0.6.8-develop.7072.1.19c2a8bbe0 → 0.6.8-develop.7077.1.94f1126c13

package/src/modules/auth/api/session/refresh.ts

@@ -2,7 +2,7 @@ import { NextResponse } from 'next/server'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { AuthService } from '@open-mercato/core/modules/auth/services/authService'
-import { signJwt } from '@open-mercato/shared/lib/auth/jwt'
+import { isMfaPendingJwtPayload, signJwt, verifyJwt } from '@open-mercato/shared/lib/auth/jwt'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import { refreshSessionRequestSchema } from '@open-mercato/core/modules/auth/data/validators'
 import { checkAuthRateLimit } from '@open-mercato/core/modules/auth/lib/rateLimitCheck'
@@ -25,6 +25,23 @@ function parseCookie(req: Request, name: string): string | null {
   return m ? decodeURIComponent(m[1]) : null
 }
 
+// Both handlers are `requireAuth: false`, so the dispatcher's MFA-pending gate never inspects
+// this route's caller. Minting a full staff JWT for a browser that is still holding a provisional
+// `mfa_pending` token would hand it the access the outstanding second factor is meant to withhold,
+// so the pending credential is checked here directly. `refreshFromSessionToken` itself has no MFA
+// awareness — it validates only the token hash and expiry.
+function carriesMfaPendingToken(req: Request): boolean {
+  const authHeader = (req.headers.get('authorization') || '').trim()
+  const bearer = authHeader.toLowerCase().startsWith('bearer ') ? authHeader.slice(7).trim() : null
+  const token = bearer || parseCookie(req, 'auth_token')
+  if (!token) return false
+  try {
+    return isMfaPendingJwtPayload(verifyJwt(token))
+  } catch {
+    return false
+  }
+}
+
 type RefreshedSession = NonNullable<Awaited<ReturnType<AuthService['refreshFromSessionToken']>>>
 
 // Scope claims must stay absent rather than stringified when the user has no tenant/org:
@@ -64,6 +81,11 @@ export async function GET(req: Request) {
   const url = new URL(req.url)
   const baseUrl = resolveTrustedRedirectBase(req) ?? url.origin
   const redirectTo = sanitizeRedirectPath(url.searchParams.get('redirect'), baseUrl, '/')
+  if (carriesMfaPendingToken(req)) {
+    return clearStaffAuthCookies(
+      buildSafeRedirectResponse(req, '/login?redirect=' + encodeURIComponent(redirectTo))
+    )
+  }
   const token = parseCookie(req, 'session_token')
   if (!token) {
     return clearStaffAuthCookies(
@@ -106,6 +128,15 @@ export async function POST(req: Request) {
   })
   if (rateLimitError) return rateLimitError
 
+  if (carriesMfaPendingToken(req)) {
+    return clearStaffAuthCookies(
+      NextResponse.json({
+        ok: false,
+        error: translate('auth.session.refresh.errors.invalidToken', 'Invalid or expired refresh token'),
+      }, { status: 401 })
+    )
+  }
+
   if (!token) {
     return clearStaffAuthCookies(
       NextResponse.json({

package/src/modules/customers/ai-tools/deals-pack.ts

@@ -27,6 +27,11 @@ import {
   CustomerDeal,
   CustomerPipelineStage,
 } from '../data/entities'
+import {
+  dealClosureOutcomeFromStatus,
+  loadClosurePipelineStageSnapshot,
+} from '../lib/closureStage'
+import { canonicalDealStatus, isClosedDealStatus } from '../lib/dealStatus'
 import {
   assertTenantScope,
   type CustomersAiToolDefinition,
@@ -469,10 +474,48 @@ const updateDealStageTool: CustomersAiToolDefinition = {
       afterPipelineStageLabel = stage?.label ?? input.toPipelineStageId
     } else if (input.toStage) {
       afterStatus = input.toStage
+      // The update command derives a closure outcome from terminal status spellings and
+      // relocates the deal to the pipeline's terminal stage (#5107) — preview that same
+      // projection so the approval card states the full blast radius.
+      const organizationId = deal.organizationId ?? ctx.organizationId ?? null
+      const outcome = dealClosureOutcomeFromStatus(input.toStage)
+      if (outcome && organizationId) {
+        const terminalStage = await loadClosurePipelineStageSnapshot(em, {
+          pipelineId: deal.pipelineId ?? null,
+          closureOutcome: outcome,
+          tenantId,
+          organizationId,
+        })
+        if (terminalStage) {
+          afterPipelineStageId = terminalStage.id
+          afterPipelineStageLabel = terminalStage.label
+        }
+      }
     }
     const beforeStatus = deal.status ?? null
     const beforePipelineStageId = deal.pipelineStageId ?? null
     const beforePipelineStageLabel = deal.pipelineStage ?? beforePipelineStageId
+    const beforeClosureOutcome = deal.closureOutcome ?? null
+    const beforeLossReasonId = deal.lossReasonId ?? null
+    const beforeLossNotes = deal.lossNotes ?? null
+    // Mirror the update command exactly (#5107): a status-only write derives the closure
+    // outcome for terminal spellings, clears outcome plus loss columns for non-closed
+    // non-terminal ones (reopen), and leaves `closed` and stage-only writes untouched.
+    // `toStage` is free-form model text, so canonicalize before the `closed` check — the
+    // command does the same, and the two must stay in lockstep or the approval card would
+    // preview a different write than the one that lands.
+    const requestedOutcome = dealClosureOutcomeFromStatus(input.toStage)
+    const clearsClosure =
+      input.toPipelineStageId === undefined &&
+      input.toStage !== undefined &&
+      !requestedOutcome &&
+      !isClosedDealStatus(canonicalDealStatus(input.toStage))
+    const afterClosureOutcome = clearsClosure
+      ? null
+      : requestedOutcome ?? beforeClosureOutcome
+    const closureOutcomeCleared = beforeClosureOutcome !== null && afterClosureOutcome === null
+    const afterLossReasonId = closureOutcomeCleared ? null : beforeLossReasonId
+    const afterLossNotes = closureOutcomeCleared ? null : beforeLossNotes
     return {
       recordId: deal.id,
       entityType: 'customers.deal',
@@ -480,23 +523,42 @@ const updateDealStageTool: CustomersAiToolDefinition = {
       before: {
         status: beforeStatus,
         pipelineStageId: beforePipelineStageId,
+        closureOutcome: beforeClosureOutcome,
+        lossReasonId: beforeLossReasonId,
+        lossNotes: beforeLossNotes,
       },
       after: {
         status: afterStatus,
         pipelineStageId: afterPipelineStageId,
+        closureOutcome: afterClosureOutcome,
+        lossReasonId: afterLossReasonId,
+        lossNotes: afterLossNotes,
       },
       display: {
         fieldLabels: {
           status: 'Status',
           pipelineStageId: 'Pipeline stage',
+          closureOutcome: 'Closure outcome',
+          lossReasonId: 'Loss reason',
+          lossNotes: 'Loss notes',
         },
         before: {
           ...(beforeStatus ? { status: titleStatus(beforeStatus) } : {}),
           ...(beforePipelineStageLabel ? { pipelineStageId: beforePipelineStageLabel } : {}),
+          ...(beforeClosureOutcome ? { closureOutcome: titleStatus(beforeClosureOutcome) } : {}),
+          ...(beforeLossReasonId ? { lossReasonId: beforeLossReasonId } : {}),
+          ...(beforeLossNotes ? { lossNotes: beforeLossNotes } : {}),
         },
         after: {
           ...(afterStatus ? { status: titleStatus(afterStatus) } : {}),
           ...(afterPipelineStageLabel ? { pipelineStageId: afterPipelineStageLabel } : {}),
+          ...(afterClosureOutcome
+            ? { closureOutcome: titleStatus(afterClosureOutcome) }
+            : closureOutcomeCleared
+              ? { closureOutcome: '—' }
+              : {}),
+          ...(afterLossReasonId ? { lossReasonId: afterLossReasonId } : {}),
+          ...(afterLossNotes ? { lossNotes: afterLossNotes } : {}),
         },
       },
     }

package/src/modules/customers/api/deals/aggregate/route.ts

@@ -14,6 +14,7 @@ import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
 import { isTenantDataEncryptionEnabled } from '@open-mercato/shared/lib/encryption/toggles'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { fetchStuckDealIds } from '../../../lib/stuckDeals'
+import { expandDealStatusAliases } from '../../../lib/dealStatus'
 import { findMatchingEntityIdsBySearchTokensAcrossSources } from '../../utils'
 import { E } from '#generated/entities.ids.generated'
 import { createLogger } from '@open-mercato/shared/lib/logger'
@@ -27,7 +28,7 @@ export const metadata = {
 const querySchema = z.object({
   pipelineId: z.string().uuid().optional(),
   search: z.string().optional(),
-  status: z.array(z.enum(['open', 'closed', 'win', 'loose'])).optional(),
+  status: z.array(z.string().max(50)).max(20).optional(),
   ownerUserId: z.array(z.string().uuid()).optional(),
   personId: z.array(z.string().uuid()).optional(),
   companyId: z.array(z.string().uuid()).optional(),
@@ -247,9 +248,11 @@ export async function GET(req: Request) {
     }
   }
   if (parsed.data.status && parsed.data.status.length) {
-    const placeholders = parsed.data.status.map(() => '?').join(',')
+    // Non-empty input always expands to a non-empty set, so this always narrows.
+    const expandedStatuses = expandDealStatusAliases(parsed.data.status)
+    const placeholders = expandedStatuses.map(() => '?').join(',')
     where.push(`status IN (${placeholders})`)
-    values.push(...parsed.data.status)
+    values.push(...expandedStatuses)
   }
   if (parsed.data.ownerUserId && parsed.data.ownerUserId.length) {
     const placeholders = parsed.data.ownerUserId.map(() => '?').join(',')
@@ -265,7 +268,14 @@ export async function GET(req: Request) {
     values.push(parsed.data.expectedCloseAtTo)
   }
   if (parsed.data.isOverdue) {
-    where.push("expected_close_at < CURRENT_DATE AND status = 'open'")
+    // Mirror the list route's precedence: the caller-supplied status filter wins, and
+    // status='open' is injected only when none was provided.
+    const hasCallerStatus = !!parsed.data.status?.length
+    if (hasCallerStatus) {
+      where.push('expected_close_at < CURRENT_DATE')
+    } else {
+      where.push("expected_close_at < CURRENT_DATE AND status = 'open'")
+    }
   }
   if (parsed.data.isStuck) {
     // Reuse the list endpoint's stuck-deal lookup so kanban headers, lane counts, and the

package/src/modules/customers/api/deals/route.ts

@@ -22,7 +22,9 @@ import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { isTenantDataEncryptionEnabled } from '@open-mercato/shared/lib/encryption/toggles'
 import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
 import { consumeAdvancedFilterState, mergeAdvancedFilterTree } from '@open-mercato/shared/lib/crud/advanced-filter-integration'
+import type { FilterGroup, FilterRule } from '@open-mercato/shared/lib/query/advanced-filter-tree'
 import { fetchStuckDealIds } from '../../lib/stuckDeals'
+import { expandDealStatusAliases } from '../../lib/dealStatus'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('customers')
@@ -31,6 +33,19 @@ const rawBodySchema = z.object({}).passthrough()
 
 const stringOrStringArray = z.union([z.string(), z.array(z.string())])
 const OPEN_DEAL_STATUSES = ['open', 'in_progress'] as const
+// Tree operators whose `status` values are rewritten through the canonical vocabulary.
+// Text (`contains`/`starts_with`/…) and range (`between`) operators are left untouched
+// so a URL-supplied rule keeps its scalar semantics.
+const STATUS_TREE_OPERATORS = new Set([
+  'is',
+  'equals',
+  'is_not',
+  'not_equals',
+  'is_any_of',
+  'has_any_of',
+  'is_none_of',
+  'has_none_of',
+])
 const booleanQueryParam = z.preprocess((value) => {
   const parsed = parseBooleanFromUnknown(value)
   return parsed === null ? value : parsed
@@ -245,6 +260,39 @@ function normalizeUuidList(values: Array<unknown>): string[] {
 
 export async function buildDealListFilters(query: DealListQuery, ctx?: import('@open-mercato/shared/lib/crud/factory').CrudCtx) {
   const advancedFilterTree = consumeAdvancedFilterState(query)
+  if (advancedFilterTree) {
+    // Expand status aliases in the advanced-filter tree so List (tree path) and
+    // Kanban (plain ?status=) share the same canonical vocabulary (#5107). Only
+    // set-membership operators are rewritten — text/range operators on `status`
+    // keep their pre-existing scalar semantics instead of being corrupted.
+    const walk = (node: FilterGroup | FilterRule): void => {
+      if (node.type === 'rule' && node.field === 'status' && STATUS_TREE_OPERATORS.has(node.operator)) {
+        const listOperators = new Set(['is_any_of', 'has_any_of', 'is_none_of', 'has_none_of'])
+        const rawValues: string[] = Array.isArray(node.value)
+          ? (node.value as unknown[]).filter((v): v is string => typeof v === 'string')
+          : typeof node.value === 'string'
+            ? [node.value]
+            : []
+        if (rawValues.length === 0) return
+        const expanded = expandDealStatusAliases(rawValues)
+        if (listOperators.has(node.operator)) {
+          node.value = expanded
+        } else if (expanded.length === 1) {
+          node.value = expanded[0]
+        } else {
+          node.value = expanded
+          if (node.operator === 'is' || node.operator === 'equals') {
+            node.operator = 'is_any_of'
+          } else if (node.operator === 'is_not' || node.operator === 'not_equals') {
+            node.operator = 'is_none_of'
+          }
+        }
+      } else if (node.type === 'group') {
+        for (const child of node.children) walk(child)
+      }
+    }
+    walk(advancedFilterTree.root)
+  }
   const filters: Record<string, unknown> = {}
   let restrictedIds: string[] | null = null
 
@@ -300,7 +348,8 @@ export async function buildDealListFilters(query: DealListQuery, ctx?: import('@
     }
   }
 
-  const statusList = query.status ? normalizeStringList(query.status) : []
+  const rawStatusList = query.status ? normalizeStringList(query.status) : []
+  const statusList = expandDealStatusAliases(rawStatusList)
   if (statusList.length > 0) {
     filters.status = statusList.length === 1 ? { $eq: statusList[0] } : { $in: statusList }
   }

package/src/modules/customers/backend/customers/deals/pipeline/components/Lane.tsx

@@ -7,6 +7,7 @@ import type { RowActionItem } from '@open-mercato/ui/backend/RowActions'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { translateWithFallback } from '@open-mercato/shared/lib/i18n/translate'
 import type { FilterOptionTone } from '@open-mercato/shared/lib/query/advanced-filter'
+import { toneToDotClass } from './toneClasses'
 import { DealCard, type DealCardData } from './DealCard'
 import { DashedTileButton } from './DashedTileButton'
 import { LANE_WIDTH_PX } from './constants'
@@ -52,15 +53,10 @@ type LaneProps = {
   onResetWidth?: (stageId: string) => void
 }
 
-// 4px color bar tone — uses saturated icon tokens so the bar is visibly colored, not pale
-const ACCENT_TONE_CLASS: Record<FilterOptionTone, string> = {
-  success: 'bg-status-success-icon',
-  error: 'bg-status-error-icon',
-  warning: 'bg-status-warning-icon',
-  info: 'bg-status-info-icon',
-  neutral: 'bg-status-neutral-icon',
-  brand: 'bg-brand-violet',
-  pink: 'bg-status-pink-icon',
+// 4px color bar tone — saturated icon tokens shared with the status filter pills
+// (toneClasses.ts) so the lane bar and the filter dots stay in lockstep (#5107 review).
+function getAccentClass(tone: FilterOptionTone | null): string {
+  return toneToDotClass(tone, 'bg-border')
 }
 
 // Count pill bg uses very-light status background, text uses status text color
@@ -74,11 +70,6 @@ const COUNT_BADGE_TONE_CLASS: Record<FilterOptionTone, string> = {
   pink: 'bg-status-pink-bg text-status-pink-text',
 }
 
-function getAccentClass(tone: FilterOptionTone | null): string {
-  if (tone && tone in ACCENT_TONE_CLASS) return ACCENT_TONE_CLASS[tone]
-  return 'bg-border'
-}
-
 function getCountBadgeClass(tone: FilterOptionTone | null): string {
   if (tone && tone in COUNT_BADGE_TONE_CLASS) return COUNT_BADGE_TONE_CLASS[tone]
   return 'bg-muted text-muted-foreground'

package/src/modules/customers/backend/customers/deals/pipeline/components/StatusFilterPopover.tsx

@@ -10,45 +10,70 @@ import {
 } from '@open-mercato/ui/primitives/popover'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { translateWithFallback } from '@open-mercato/shared/lib/i18n/translate'
+import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
+import { mapDictionaryColorToTone } from '@open-mercato/shared/lib/query/advanced-filter'
+import { Spinner } from '@open-mercato/ui/primitives/spinner'
+import { useCustomerDictionary } from '../../../../../components/detail/hooks/useCustomerDictionary'
+import { canonicalDealStatus } from '../../../../../lib/dealStatus'
+import { toneToDotClass } from './toneClasses'
 import { ChipButton } from './ChipButton'
 import { FilterPopoverShell } from './FilterPopoverShell'
 
 /**
  * Filter options exposed to the operator.
  *
- * The deal `status` column accepts the historical 4-value enum (`open` | `closed` | `win` |
- * `loose`), but the codebase only ever **writes** `loose` for a lost deal — `closed` was a
- * latent unused state from an earlier iteration. Exposing a separate "Lost (closed)" filter
- * option therefore filtered to nothing and confused operators. We display a single "Lost"
- * choice and intentionally map it to the canonical wire value `loose` so the filter matches
- * what the rest of the app actually persists. (Renaming the column / migrating the data to
- * `lost` is a deeper data-model change tracked separately.)
+ * The deal `status` column is dictionary-driven (`deal-statuses`); the seeded dictionary
+ * carries five values (`open`, `closed`, `win`, `loose`, `in_progress`) plus any
+ * tenant-custom entries. We render every dictionary entry de-duplicated by canonical
+ * spelling so the kanban Status pill stays aligned with the list page's advanced filter
+ * (which also uses the dictionary). A hard-coded fallback keeps the popover usable while
+ * the dictionary is loading or when a tenant has no entries.
+ *
+ * `won` / `lost` are accepted as aliases for `win` / `loose` at the API layer (see
+ * `lib/dealStatus.ts:expandDealStatusAliases`, shared by the deals list route and the
+ * kanban aggregate route). The UI only exposes the canonical values to avoid duplicate
+ * pills, but `canonicalDealStatus` normalizes any alias passed in through `values` so
+ * the chip and draft selection render the correct label.
  */
-const STATUS_OPTIONS: Array<{
+const FALLBACK_STATUS_OPTIONS: Array<{
   value: string
   labelKey: string
   labelFallback: string
-  /** Tone selects the small ●-dot color on the pill (per Figma: green / amber / gray) */
   dotClass: string
 }> = [
   {
     value: 'open',
     labelKey: 'customers.deals.kanban.filter.status.open',
     labelFallback: 'Open',
-    dotClass: 'bg-status-success-icon',
+    // Tones mirror mapDictionaryColorToTone over the seeded dictionary colors
+    // (#2563eb → info, #22c55e → success, #ef4444 → error) so the fallback pills
+    // render identically to the dictionary-driven ones.
+    dotClass: 'bg-status-info-icon',
   },
   {
     value: 'win',
     labelKey: 'customers.deals.kanban.filter.status.won',
     labelFallback: 'Won',
-    dotClass: 'bg-status-warning-icon',
+    dotClass: 'bg-status-success-icon',
   },
   {
     value: 'loose',
     labelKey: 'customers.deals.kanban.filter.status.lost',
     labelFallback: 'Lost',
+    dotClass: 'bg-status-error-icon',
+  },
+  {
+    value: 'closed',
+    labelKey: 'customers.deals.kanban.filter.status.closed',
+    labelFallback: 'Closed',
     dotClass: 'bg-status-neutral-icon',
   },
+  {
+    value: 'in_progress',
+    labelKey: 'customers.deals.kanban.filter.status.inProgress',
+    labelFallback: 'In progress',
+    dotClass: 'bg-status-warning-icon',
+  },
 ]
 
 type StatusFilterPopoverProps = {
@@ -58,29 +83,75 @@ type StatusFilterPopoverProps = {
 
 export function StatusFilterPopover({ values, onApply }: StatusFilterPopoverProps): React.ReactElement {
   const t = useT()
+  const scopeVersion = useOrganizationScopeVersion()
+  const { data: dictionaryData, isLoading: dictionaryLoading } = useCustomerDictionary(
+    'deal-statuses',
+    scopeVersion,
+  )
   const [open, setOpen] = React.useState(false)
-  const [draft, setDraft] = React.useState<string[]>(values)
+  const normalizedValues = React.useMemo(
+    () => Array.from(new Set(values.map(canonicalDealStatus))),
+    [values],
+  )
+  const [draft, setDraft] = React.useState<string[]>(normalizedValues)
 
   React.useEffect(() => {
-    if (open) setDraft(values)
-  }, [open, values])
+    if (open) setDraft(normalizedValues)
+  }, [open, normalizedValues])
+
+  const statusOptions = React.useMemo(() => {
+    const entries = dictionaryData?.entries
+    if (entries && entries.length > 0) {
+      const byCanonical = new Map<string, { value: string; label: string; dotClass: string }>()
+      for (const entry of entries) {
+        const canonical = canonicalDealStatus(entry.value)
+        if (byCanonical.has(canonical)) continue
+        const tone = mapDictionaryColorToTone(entry.color ?? null)
+        byCanonical.set(canonical, {
+          value: canonical,
+          label: entry.label,
+          dotClass: toneToDotClass(tone),
+        })
+      }
+      // Sort by label exactly like the List page's advanced filter
+      // (backend/customers/deals/page.tsx dictionaryOptions) so both surfaces render
+      // the same pills in the same order.
+      return Array.from(byCanonical.values()).sort((a, b) =>
+        a.label.localeCompare(b.label, undefined, { sensitivity: 'base' }),
+      )
+    }
+    return FALLBACK_STATUS_OPTIONS.map((entry) => ({
+      value: entry.value,
+      label: translateWithFallback(t, entry.labelKey, entry.labelFallback),
+      dotClass: entry.dotClass,
+    }))
+  }, [dictionaryData, t])
+
+  const labelByValue = React.useMemo(() => {
+    const map = new Map<string, string>()
+    for (const option of statusOptions) {
+      map.set(option.value, option.label)
+    }
+    for (const fallback of FALLBACK_STATUS_OPTIONS) {
+      if (!map.has(fallback.value)) {
+        map.set(fallback.value, translateWithFallback(t, fallback.labelKey, fallback.labelFallback))
+      }
+    }
+    return map
+  }, [statusOptions, t])
 
   const chipLabel = translateWithFallback(t, 'customers.deals.kanban.filter.status', 'Status')
   const chipValue =
-    values.length === 0
+    normalizedValues.length === 0
       ? translateWithFallback(t, 'customers.deals.kanban.filter.all', 'All')
-      : values
-          .map((value) => {
-            const option = STATUS_OPTIONS.find((entry) => entry.value === value)
-            return option
-              ? translateWithFallback(t, option.labelKey, option.labelFallback)
-              : value
-          })
+      : normalizedValues
+          .map((value) => labelByValue.get(value) ?? value)
           .join(', ')
 
   const toggleDraft = (value: string) => {
+    const normalized = canonicalDealStatus(value)
     setDraft((prev) =>
-      prev.includes(value) ? prev.filter((entry) => entry !== value) : [...prev, value],
+      prev.includes(normalized) ? prev.filter((entry) => entry !== normalized) : [...prev, normalized],
     )
   }
 
@@ -101,7 +172,7 @@ export function StatusFilterPopover({ values, onApply }: StatusFilterPopoverProp
   return (
     <Popover open={open} onOpenChange={setOpen}>
       <PopoverTrigger asChild>
-        <ChipButton label={chipLabel} value={chipValue} active={values.length > 0} />
+        <ChipButton label={chipLabel} value={chipValue} active={normalizedValues.length > 0} />
       </PopoverTrigger>
       <PopoverContent
         className="w-96 rounded-2xl border-border bg-transparent p-0 shadow-xl"
@@ -133,9 +204,19 @@ export function StatusFilterPopover({ values, onApply }: StatusFilterPopoverProp
             {translateWithFallback(t, 'customers.deals.kanban.filter.status', 'Status')}
           </span>
           <div className="flex flex-wrap items-center gap-x-1.5 gap-y-2">
-            {STATUS_OPTIONS.map((option) => {
+            {dictionaryLoading ? (
+              <span className="flex items-center gap-2 text-xs text-muted-foreground" role="status" aria-live="polite">
+                <Spinner className="size-3" />
+                {translateWithFallback(
+                  t,
+                  'customers.deals.kanban.filter.status.loading',
+                  'Loading statuses…',
+                )}
+              </span>
+            ) : (
+              statusOptions.map((option) => {
               const isSelected = draft.includes(option.value)
-              const label = translateWithFallback(t, option.labelKey, option.labelFallback)
+              const label = option.label
               return (
                 <Button
                   key={option.value}
@@ -160,7 +241,8 @@ export function StatusFilterPopover({ values, onApply }: StatusFilterPopoverProp
                   ) : null}
                 </Button>
               )
-            })}
+              })
+            )}
           </div>
         </FilterPopoverShell>
       </PopoverContent>

package/src/modules/customers/backend/customers/deals/pipeline/components/toneClasses.ts

@@ -0,0 +1,21 @@
+import type { FilterOptionTone } from '@open-mercato/shared/lib/query/advanced-filter'
+
+// Saturated icon tokens shared by the kanban lane accent bar and the status filter
+// pills, so both surfaces render the same tone identically (#5107 review).
+export const TONE_DOT_CLASS: Record<FilterOptionTone, string> = {
+  success: 'bg-status-success-icon',
+  error: 'bg-status-error-icon',
+  warning: 'bg-status-warning-icon',
+  info: 'bg-status-info-icon',
+  neutral: 'bg-status-neutral-icon',
+  brand: 'bg-brand-violet',
+  pink: 'bg-status-pink-icon',
+}
+
+export function toneToDotClass(
+  tone: FilterOptionTone | null | undefined,
+  fallback = 'bg-status-neutral-icon',
+): string {
+  if (tone && tone in TONE_DOT_CLASS) return TONE_DOT_CLASS[tone]
+  return fallback
+}