@open-mercato/core 0.6.7-develop.6863.1.61001cf9a8 → 0.6.7

package/src/modules/query_index/cli.ts

@@ -11,7 +11,7 @@ type ProgressBarHandle = {
   update(completed: number): void
   complete(): void
 }
-import { resolveEntityTableName, resolveRegisteredEntityTableName } from '@open-mercato/shared/lib/query/engine'
+import { resolveEntityTableName } from '@open-mercato/shared/lib/query/engine'
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
 import { recordIndexerLog } from '@open-mercato/shared/lib/indexers/status-log'
 import {
@@ -23,7 +23,6 @@ import {
 } from './lib/batch'
 import { reindexEntity, DEFAULT_REINDEX_PARTITIONS } from './lib/reindexer'
 import { purgeIndexScope } from './lib/purge'
-import { refreshCoverageSnapshot } from './lib/coverage'
 import { flattenSystemEntityIds } from '@open-mercato/shared/lib/entities/system-entities'
 import type { VectorIndexService } from '@open-mercato/search/vector'
 
@@ -341,168 +340,6 @@ function describeScope(scope: ScopeDescriptor): string {
   return parts.length ? ` (${parts.join(' ')})` : ''
 }
 
-/**
- * Above this many missing records the anti-join stops being the cheaper option and the
- * repair falls back to a full single-partition rebuild of the entity.
- */
-const MAX_TARGETED_REPAIR_RECORDS = 5000
-
-/**
- * List the base records in scope that have no live index row, so a repair rebuilds only
- * what is actually missing instead of re-upserting the whole entity for a one-row gap.
- */
-async function findUnindexedRecordIds(
-  db: Kysely<any>,
-  options: {
-    entityType: string
-    tableName: string
-    tenantId?: string | null
-    organizationId?: string | null
-    limit: number
-  },
-): Promise<string[]> {
-  const columns = await getColumnSet(db, options.tableName)
-  let query = db
-    .selectFrom(`${options.tableName} as b` as any)
-    .select('b.id' as any)
-    .where(({ not, exists, selectFrom }: any) =>
-      not(exists(
-        selectFrom('entity_indexes as ei' as any)
-          .select(sql`1`.as('one'))
-          .whereRef('ei.entity_id' as any, '=', sql`b.id::text`)
-          .where('ei.entity_type' as any, '=', options.entityType)
-          .where('ei.deleted_at' as any, 'is', null as any),
-      )),
-    )
-    .limit(options.limit)
-  if (columns.has('deleted_at')) query = query.where('b.deleted_at' as any, 'is', null as any)
-  if (options.tenantId != null && columns.has('tenant_id')) {
-    query = query.where('b.tenant_id' as any, '=', options.tenantId)
-  }
-  if (options.organizationId != null && columns.has('organization_id')) {
-    query = query.where('b.organization_id' as any, '=', options.organizationId)
-  }
-  const rows = await query.execute() as Array<{ id: unknown }>
-  return rows.map((row) => String(row.id))
-}
-
-/**
- * Recount the scope from the database after a reindex and rebuild whatever is still
- * missing. Runs unconditionally so `mercato init` (and any scripted reindex) cannot finish
- * leaving a gap that a human has to notice and repair by hand from the Query Indexes
- * screen. When counts already agree this is two COUNT queries; when they do not, the
- * repair is scoped to the records the anti-join says are actually missing.
- */
-async function verifyAndRepairIndexCoverage(
-  em: EntityManager,
-  options: {
-    entityType: string
-    tenantId?: string | null
-    organizationId?: string | null
-    batchSize?: number
-  },
-): Promise<void> {
-  const scope = {
-    entityType: options.entityType,
-    tenantId: options.tenantId ?? null,
-    organizationId: options.organizationId ?? null,
-    withDeleted: false,
-  }
-
-  let counts: { baseCount: number; indexedCount: number } | null = null
-  try {
-    counts = await refreshCoverageSnapshot(em, scope)
-  } catch (error) {
-    console.warn(
-      `  -> ${options.entityType}: coverage verification skipped (${error instanceof Error ? error.message : String(error)})`,
-    )
-    return
-  }
-  if (!counts) return
-  if (counts.indexedCount > counts.baseCount) {
-    // Legitimate for entities whose base table cannot express the scope, since a per-tenant
-    // reindex stamps its own scope onto every row. Surfaced rather than repaired: a rebuild
-    // cannot remove the surplus, and the over-count would otherwise mask a real shortfall.
-    console.warn(
-      `  -> ${options.entityType}: ${counts.indexedCount} index rows for ${counts.baseCount} records — not repairable by reindexing`,
-    )
-    return
-  }
-  if (counts.indexedCount === counts.baseCount) return
-
-  const db = (em as any).getKysely() as Kysely<any>
-  let tableName: string | null = null
-  try {
-    tableName = resolveRegisteredEntityTableName(em as any, options.entityType)
-  } catch {
-    tableName = null
-  }
-
-  const missingIds = tableName
-    ? await findUnindexedRecordIds(db, {
-      entityType: options.entityType,
-      tableName,
-      tenantId: options.tenantId ?? null,
-      organizationId: options.organizationId ?? null,
-      limit: MAX_TARGETED_REPAIR_RECORDS + 1,
-    }).catch(() => null)
-    : null
-
-  const targeted = missingIds && missingIds.length > 0 && missingIds.length <= MAX_TARGETED_REPAIR_RECORDS
-  console.log(
-    `  -> ${options.entityType}: ${counts.indexedCount}/${counts.baseCount} indexed after reindex — repairing`
-    + `${targeted ? ` ${missingIds!.length} missing record(s)` : ' the whole entity'}...`,
-  )
-
-  try {
-    if (targeted) {
-      const columns = await getColumnSet(db, tableName!)
-      for (const recordId of missingIds!) {
-        await rebuildEntityIndexes({
-          em,
-          db,
-          entityType: options.entityType,
-          tableName: tableName!,
-          orgOverride: options.organizationId ?? undefined,
-          tenantOverride: options.tenantId ?? undefined,
-          global: false,
-          includeDeleted: false,
-          offset: 0,
-          recordId,
-          batchSize: 1,
-          supportsOrgFilter: columns.has('organization_id'),
-          supportsTenantFilter: columns.has('tenant_id'),
-          supportsDeletedFilter: columns.has('deleted_at'),
-        })
-      }
-    } else {
-      await reindexEntity(em, {
-        entityType: options.entityType,
-        tenantId: options.tenantId,
-        organizationId: options.organizationId,
-        force: false,
-        batchSize: options.batchSize,
-        emitVectorizeEvents: false,
-        resetCoverage: false,
-      })
-    }
-  } catch (error) {
-    console.warn(
-      `  -> ${options.entityType}: repair pass failed (${error instanceof Error ? error.message : String(error)})`,
-    )
-    return
-  }
-
-  const after = await refreshCoverageSnapshot(em, scope).catch(() => null)
-  if (after && after.indexedCount < after.baseCount) {
-    console.warn(
-      `  -> ${options.entityType}: still ${after.indexedCount}/${after.baseCount} indexed after repair`,
-    )
-  } else {
-    console.log(`  -> ${options.entityType}: coverage repaired`)
-  }
-}
-
 const rebuild: ModuleCli = {
   command: 'rebuild',
   async run(rest) {
@@ -873,14 +710,6 @@ const reindex: ModuleCli = {
         groupedProgress?.complete()
         const totalProcessed = stats.reduce((acc, value) => acc + value, 0)
         console.log(`Finished ${entity}: processed ${totalProcessed} row(s) across ${partitionTargets.length} partition(s)`)
-        if (partitionIndexOption === undefined) {
-          await verifyAndRepairIndexCoverage(baseEm, {
-            entityType: entity,
-            tenantId,
-            organizationId: orgId,
-            batchSize,
-          })
-        }
         await recordIndexerLog(
           { em: baseEm },
           {
@@ -1019,14 +848,6 @@ const reindex: ModuleCli = {
         groupedProgress?.complete()
         const totalProcessed = partitionResults.reduce((acc, value) => acc + value, 0)
         console.log(`  -> ${id} complete: processed ${totalProcessed} row(s) across ${partitionTargets.length} partition(s)`)
-        if (partitionIndexOption === undefined) {
-          await verifyAndRepairIndexCoverage(baseEm, {
-            entityType: id,
-            tenantId,
-            organizationId: orgId,
-            batchSize,
-          })
-        }
         await recordIndexerLog(
           { em: baseEm },
           {

package/src/modules/query_index/components/QueryIndexesTable.tsx

@@ -1,10 +1,8 @@
 "use client"
 import * as React from 'react'
-import { extensionPoints } from '@open-mercato/core/modules/query_index/extension-points'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
 import type { ColumnDef, SortingState } from '@tanstack/react-table'
 import { DataTable } from '@open-mercato/ui/backend/DataTable'
-import type { FilterDef, FilterValues } from '@open-mercato/ui/backend/FilterBar'
 import { RowActions } from '@open-mercato/ui/backend/RowActions'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { apiCallOrThrow, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
@@ -54,54 +52,15 @@ type Row = {
   baseCount: number | null
   indexCount: number | null
   vectorCount: number | null
-  /** The entity is configured for vector search (declares `buildSource`). */
   vectorEnabled: boolean
-  /** Vector indexing can actually run — provider reachable and auto-indexing on. */
-  vectorIndexingActive?: boolean
   fulltextCount: number | null
   fulltextEnabled: boolean
-  hasCustomFields?: boolean
-  /** Legacy aggregate: query index AND vector coverage. Preserved for API consumers. */
   ok: boolean
-  /** Query index alone is in sync with the base table — the signal this page reports. */
-  queryIndexOk?: boolean
   job?: JobStatus
 }
 
 type Resp = { items: Row[] }
 
-const BACKEND_FILTER_ID = 'backend'
-// Kept at or below the repository-wide 100-row cap; the entity list grows with every
-// installed module, so it cannot be allowed to scale with the row count.
-const PAGE_SIZE = 50
-
-/** Sort key for a column id. Mirrors the column `accessorFn`s so paging and sorting agree. */
-function sortValue(row: Row, columnId: string): string | number {
-  if (columnId === 'entityId') return row.entityId
-  if (columnId === 'baseCount') return row.baseCount ?? 0
-  if (columnId === 'indexCount') return row.indexCount ?? 0
-  if (columnId === 'vectorCount') return isVectorReportable(row) ? row.vectorCount ?? 0 : -1
-  if (columnId === 'fulltextCount') return row.fulltextEnabled ? row.fulltextCount ?? 0 : -1
-  return row.entityId
-}
-
-type BackendFilter = 'vector' | 'fulltext' | 'custom_fields'
-
-/**
- * Vector coverage is only worth showing when embeddings can actually be written; otherwise
- * the count is a permanent 0 that reads as a gap. Older payloads without the flag are
- * treated as active so the column keeps working against an un-upgraded server.
- */
-function isVectorReportable(row: Row): boolean {
-  return row.vectorEnabled && (row.vectorIndexingActive ?? true)
-}
-
-function matchesBackendFilter(row: Row, backend: BackendFilter): boolean {
-  if (backend === 'vector') return row.vectorEnabled
-  if (backend === 'fulltext') return row.fulltextEnabled
-  return Boolean(row.hasCustomFields)
-}
-
 function formatCount(value: number | null): string {
   if (value == null) return '—'
   return value.toLocaleString()
@@ -124,24 +83,15 @@ function formatProgressLabel(
   return t('query_index.table.status.progressSingle', { processed: processedText })
 }
 
-function translateJobStatus(
-  t: Translator,
-  status: JobStatus['status'] | undefined,
-  ok: boolean,
-  measured: boolean,
-): string {
-  const idleLabel = () => {
-    // No coverage snapshot yet — an async refresh is pending, so the index is not known to
-    // be out of sync. Saying so would be the same false alarm this page used to raise.
-    if (!measured) return t('query_index.table.status.not_measured')
+function translateJobStatus(t: Translator, status: JobStatus['status'] | undefined, ok: boolean): string {
+  if (!status || status === 'idle') {
     return ok ? t('query_index.table.status.in_sync') : t('query_index.table.status.out_of_sync')
   }
-  if (!status || status === 'idle') return idleLabel()
   if (status === 'reindexing') return t('query_index.table.status.reindexing')
   if (status === 'purging') return t('query_index.table.status.purging')
   if (status === 'stalled') return t('query_index.table.status.stalled')
   if (status === 'failed') return t('query_index.table.status.failed')
-  return idleLabel()
+  return ok ? t('query_index.table.status.in_sync') : t('query_index.table.status.out_of_sync')
 }
 
 function translateScopeStatus(
@@ -158,15 +108,8 @@ function translateScopeStatus(
 
 function createColumns(t: Translator): ColumnDef<Row>[] {
   return [
-    {
-      id: 'entityId',
-      header: () => t('query_index.table.columns.entity'),
-      accessorKey: 'entityId',
-      // The entity id is the only identifier on this page and ids run to ~45 characters
-      // (`catalog:catalog_product_category_assignment`). DataTable's default 150px clamp
-      // ellipsised them into indistinguishable `customers:customer…` rows.
-      meta: { priority: 1, maxWidth: '340px' },
-    },
+    { id: 'entityId', header: () => t('query_index.table.columns.entity'), accessorKey: 'entityId', meta: { priority: 1 } },
+    { id: 'label', header: () => t('query_index.table.columns.label'), accessorKey: 'label', meta: { priority: 2 } },
     {
       id: 'baseCount',
       header: () => t('query_index.table.columns.records'),
@@ -184,10 +127,10 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
     {
       id: 'vectorCount',
       header: () => t('query_index.table.columns.vector'),
-      accessorFn: (row) => (isVectorReportable(row) ? row.vectorCount ?? 0 : -1),
+      accessorFn: (row) => (row.vectorEnabled ? row.vectorCount ?? 0 : -1),
       cell: ({ row }) => {
         const record = row.original
-        if (!isVectorReportable(record)) return <span>—</span>
+        if (!record.vectorEnabled) return <span>—</span>
         const ok = record.vectorCount != null && record.baseCount != null && record.vectorCount === record.baseCount
         const display = formatCount(record.vectorCount)
         const className = ok ? 'text-status-success-text' : 'text-status-warning-text'
@@ -216,45 +159,17 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
         const record = row.original
         const job = record.job
         const partitions = job?.partitions ?? []
-        const measured = record.baseCount != null || record.indexCount != null
-
-        // A non-partitioned reindex — and every purge, which never partitions
-        // (`lib/purge.ts` always passes `partitionIndex: null`) — is tracked as a scope row.
-        // The server derives the top-level status from partition rows only, so it reports
-        // `idle` for those runs; without folding the scope row in, the default reindex and
-        // every purge would render as though nothing were happening.
-        const scopeStatus = job?.scope?.status ?? null
-        const scopeInFlight = scopeStatus != null && scopeStatus !== 'completed'
-        const effectiveStatus: JobStatus['status'] | undefined = job
-          ? (job.status !== 'idle'
-              ? job.status
-              : (scopeInFlight ? (scopeStatus as JobStatus['status']) : 'idle'))
-          : undefined
-
-        const indexOk = record.queryIndexOk ?? record.ok
-        const ok = indexOk && (!job || effectiveStatus === 'idle')
-        const jobFailed = effectiveStatus === 'failed'
-        const statusText = translateJobStatus(t, effectiveStatus, ok, measured)
-
-        const jobInFlight = Boolean(effectiveStatus && effectiveStatus !== 'idle')
-          || partitions.some((part) => part.status !== 'completed')
-
-        // Job counters and index coverage are different numbers: the counters describe the
-        // last reindex run, the Records/Indexed columns describe the index right now. While
-        // a job runs, "Reindexing (5/14)" is the only place progress is visible. Once it is
-        // idle the counters are stale and duplicate the columns — worse, they can contradict
-        // them: an entity whose last run processed 14 rows but landed 2 in the index rendered
-        // "Out of sync (14/14)" next to Records 14 / Indexed 2.
-        const jobProgress = jobInFlight && job
-          ? formatProgressLabel(job.processedCount ?? null, job.totalCount ?? null, t)
-          : null
+        const ok = record.ok && (!job || job.status === 'idle')
+        const jobFailed = job?.status === 'failed'
+        const statusText = translateJobStatus(t, job?.status, ok)
+        const jobProgress = job ? formatProgressLabel(job.processedCount ?? null, job.totalCount ?? null, t) : null
         const label = jobProgress
           ? t('query_index.table.status.withProgress', { status: statusText, progress: jobProgress })
           : statusText
         let variant: StatusBadgeVariant = 'neutral'
         if (job) {
-          if (effectiveStatus === 'stalled' || jobFailed) variant = 'error'
-          else if (effectiveStatus === 'reindexing' || effectiveStatus === 'purging') variant = 'warning'
+          if (job.status === 'stalled' || jobFailed) variant = 'error'
+          else if (job.status === 'reindexing' || job.status === 'purging') variant = 'warning'
           else variant = ok ? 'success' : 'neutral'
         } else {
           variant = ok ? 'success' : 'neutral'
@@ -262,30 +177,35 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
 
         const lines: string[] = []
 
-        // Per-partition detail earns its space only while work is in flight — that is when
-        // it tells you which partition is running or stuck. Once the job is idle and every
-        // partition is finished, each line just restates the badge, on every row.
-        if (jobInFlight) {
-          if (job?.scope && partitions.length <= 1) {
-            const scopeStatusText = translateScopeStatus(t, scopeStatus)
-            const scopeProgress = formatProgressLabel(job.scope.processedCount ?? null, job.scope.totalCount ?? null, t)
-            const scopeLabel = t('query_index.table.status.scopeLabel')
-            lines.push(`${scopeLabel}: ${scopeStatusText}${scopeProgress ? ` (${scopeProgress})` : ''}`)
-          }
+        if (job?.scope && partitions.length <= 1) {
+          const scopeStatus = translateScopeStatus(t, job.scope.status ?? null)
+          const scopeProgress = formatProgressLabel(job.scope.processedCount ?? null, job.scope.totalCount ?? null, t)
+          const scopeLabel = t('query_index.table.status.scopeLabel')
+          lines.push(`${scopeLabel}: ${scopeStatus}${scopeProgress ? ` (${scopeProgress})` : ''}`)
+        }
 
-          if (partitions.length > 1) {
-            for (const part of partitions) {
-              const partitionLabel =
-                part.partitionIndex != null
-                  ? t('query_index.table.status.partitionLabel', { index: Number(part.partitionIndex) + 1 })
-                  : t('query_index.table.status.scopeLabel')
-              const partitionStatus = translateScopeStatus(t, part.status)
-              const partitionProgress = formatProgressLabel(part.processedCount ?? null, part.totalCount ?? null, t)
-              lines.push(`${partitionLabel}: ${partitionStatus}${partitionProgress ? ` (${partitionProgress})` : ''}`)
-            }
+        if (partitions.length > 1) {
+          for (const part of partitions) {
+            const partitionLabel =
+              part.partitionIndex != null
+                ? t('query_index.table.status.partitionLabel', { index: Number(part.partitionIndex) + 1 })
+                : t('query_index.table.status.scopeLabel')
+            const partitionStatus = translateScopeStatus(t, part.status)
+            const partitionProgress = formatProgressLabel(part.processedCount ?? null, part.totalCount ?? null, t)
+            lines.push(`${partitionLabel}: ${partitionStatus}${partitionProgress ? ` (${partitionProgress})` : ''}`)
           }
         }
 
+        if (record.vectorEnabled) {
+          const vectorLabel = t('query_index.table.status.vectorLabel')
+          const vectorCount = formatCount(record.vectorCount)
+          const vectorTotal = record.baseCount != null ? formatCount(record.baseCount) : null
+          const vectorValue = vectorTotal
+            ? t('query_index.table.status.vectorValue', { count: vectorCount, total: vectorTotal })
+            : vectorCount
+          lines.push(`${vectorLabel}: ${vectorValue}`)
+        }
+
         return (
           <div className="space-y-1.5">
             <div>
@@ -310,27 +230,14 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
 
 export default function QueryIndexesTable() {
   const [sorting, setSorting] = React.useState<SortingState>([{ id: 'entityId', desc: false }])
-  const [search, setSearch] = React.useState('')
   const [page, setPage] = React.useState(1)
-  const [filterValues, setFilterValues] = React.useState<FilterValues>({})
+  const [search, setSearch] = React.useState('')
   const qc = useQueryClient()
   const scopeVersion = useOrganizationScopeVersion()
   const [refreshSeq, setRefreshSeq] = React.useState(0)
   const t = useT()
   const { confirm, ConfirmDialogElement } = useConfirmDialog()
   const columns = React.useMemo(() => createColumns(t), [t])
-  const filters = React.useMemo<FilterDef[]>(() => [
-    {
-      id: BACKEND_FILTER_ID,
-      label: t('query_index.table.filters.backend'),
-      type: 'select',
-      options: [
-        { label: t('query_index.table.filters.backendOptions.vector'), value: 'vector' },
-        { label: t('query_index.table.filters.backendOptions.fulltext'), value: 'fulltext' },
-        { label: t('query_index.table.filters.backendOptions.customFields'), value: 'custom_fields' },
-      ],
-    },
-  ], [t])
   const { runMutation, retryLastMutation } = useGuardedMutation<{
     formId: string
     resourceKind: string
@@ -356,49 +263,11 @@ export default function QueryIndexesTable() {
   })
 
   const rowsAll = data?.items || []
-  const matchedRows = React.useMemo(() => {
-    const backend = filterValues[BACKEND_FILTER_ID] as BackendFilter | undefined
-    const q = search.trim().toLowerCase()
-    if (!q && !backend) return rowsAll
-    return rowsAll.filter((row) => {
-      if (q && !row.entityId.toLowerCase().includes(q)) return false
-      if (backend && !matchesBackendFilter(row, backend)) return false
-      return true
-    })
-  }, [rowsAll, search, filterValues])
-
-  // The endpoint returns every entity in one payload, so paging is ours to do. Sorting has
-  // to happen here rather than in the table: slicing first would let DataTable sort only the
-  // visible page, so page 2 would not hold the rows that sort into it.
-  const sortedRows = React.useMemo(() => {
-    const sort = sorting[0]
-    if (!sort) return matchedRows
-    const direction = sort.desc ? -1 : 1
-    return [...matchedRows].sort((a, b) => {
-      const left = sortValue(a, sort.id)
-      const right = sortValue(b, sort.id)
-      if (typeof left === 'string' || typeof right === 'string') {
-        return String(left).localeCompare(String(right)) * direction
-      }
-      return (Number(left) - Number(right)) * direction
-    })
-  }, [matchedRows, sorting])
-
-  const total = sortedRows.length
-  const totalPages = Math.max(1, Math.ceil(total / PAGE_SIZE))
-  const currentPage = Math.min(page, totalPages)
-  const rows = React.useMemo(
-    () => sortedRows.slice((currentPage - 1) * PAGE_SIZE, currentPage * PAGE_SIZE),
-    [sortedRows, currentPage],
-  )
-
-  const pagination = React.useMemo(() => ({
-    page: currentPage,
-    pageSize: PAGE_SIZE,
-    total,
-    totalPages,
-    onPageChange: setPage,
-  }), [currentPage, total, totalPages])
+  const rows = React.useMemo(() => {
+    if (!search) return rowsAll
+    const q = search.toLowerCase()
+    return rowsAll.filter((r) => r.entityId.toLowerCase().includes(q) || r.label.toLowerCase().includes(q))
+  }, [rowsAll, search])
 
   const trigger = React.useCallback(
     async (action: 'reindex' | 'purge', entityId: string, opts?: { force?: boolean }) => {
@@ -547,24 +416,10 @@ export default function QueryIndexesTable() {
           setSearch(value)
           setPage(1)
         }}
-        filters={filters}
-        filterValues={filterValues}
-        onFiltersApply={(values) => {
-          setFilterValues(values)
-          setPage(1)
-        }}
-        onFiltersClear={() => {
-          setFilterValues({})
-          setPage(1)
-        }}
         sortable
-        manualSorting
         sorting={sorting}
-        onSortingChange={(next) => {
-          setSorting(next)
-          setPage(1)
-        }}
-        perspective={{ tableId: extensionPoints.hosts.statusTable.tableId }}
+        onSortingChange={setSorting}
+        perspective={{ tableId: 'query_index.status.list' }}
         rowActions={(row) => {
           const items: Array<{ id: string; label: string; onSelect: () => void; destructive?: boolean }> = [
             { id: 'reindex', label: t('query_index.table.actions.reindex'), onSelect: () => void trigger('reindex', row.entityId) },
@@ -581,8 +436,6 @@ export default function QueryIndexesTable() {
             },
           ]
 
-          // Manual vector actions stay available whenever the entity declares `buildSource`,
-          // even when auto-indexing is off — a manual reindex is still a valid operation.
           if (row.vectorEnabled) {
             items.push(
               {
@@ -617,7 +470,7 @@ export default function QueryIndexesTable() {
 
           return <RowActions items={items} />
         }}
-        pagination={pagination}
+        pagination={{ page, pageSize: 50, total: rows.length, totalPages: 1, onPageChange: setPage }}
         isLoading={isLoading}
       />
       {ConfirmDialogElement}

package/src/modules/query_index/data/entities.ts

@@ -255,13 +255,6 @@ export class IndexerStatusLog {
 @Index({ name: 'search_tokens_lookup_idx', properties: ['entityType', 'field', 'tokenHash', 'tenantId', 'organizationId'] })
 @Index({ name: 'search_tokens_entity_idx', properties: ['entityType', 'entityId'] })
 @Index({ name: 'search_tokens_tenant_token_hash_idx', properties: ['tenantId', 'tokenHash'] })
-// Serves the availability probe ("does this scope have any tokens?") as a pure
-// B-tree prefix seek, making the MISS as cheap as the hit — neither existing
-// index can (lookup_idx buries tenant_id behind field/token_hash), which is how
-// the probe degraded to a seq scan on large tables (#4723). Requires the
-// index-usable `= / IS NULL` predicates the availability resolver emits; see
-// .ai/specs/2026-07-31-search-token-probe-index.md.
-@Index({ name: 'search_tokens_presence_idx', properties: ['entityType', 'tenantId', 'organizationId'] })
 export class SearchToken {
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string

package/src/modules/query_index/di.ts

@@ -4,7 +4,6 @@ import { HybridQueryEngine } from './lib/engine'
 import { markDeleted } from './lib/indexer'
 import type { EventBus } from '@open-mercato/events'
 import type { VectorIndexService } from '@open-mercato/search/vector'
-import { CRUD_QUERY_INDEX_MANAGED_PAYLOAD_KEY } from '@open-mercato/shared/lib/crud/types'
 
 function toEntityTypeFromEvent(event: string): string | null {
   // Expect '<module>.<entity>.<action>'
@@ -66,10 +65,6 @@ export function register(container: AppContainer) {
 
     const makeUpsertHandler = (entityType: string) => async (payload: any, ctx: any) => {
       try {
-        // DataEngine emits the canonical query_index.upsert_one itself. The
-        // bridge only covers domain events from write paths that do not own an
-        // indexer, otherwise failures and error logs are duplicated.
-        if (payload?.[CRUD_QUERY_INDEX_MANAGED_PAYLOAD_KEY] === true) return
         const em = ctx.resolve('em')
         let orgId = payload?.organizationId || payload?.orgId || ctx?.organizationId || null
         let tenantId = payload?.tenantId || ctx?.tenantId || null
@@ -123,7 +118,6 @@ export function register(container: AppContainer) {
     }
     const makeDeleteHandler = (entityType: string) => async (payload: any, ctx: any) => {
       try {
-        if (payload?.[CRUD_QUERY_INDEX_MANAGED_PAYLOAD_KEY] === true) return
         const em = ctx.resolve('em')
         let orgId = payload?.organizationId || payload?.orgId || ctx?.organizationId || null
         let tenantId = payload?.tenantId || ctx?.tenantId || null

package/src/modules/query_index/i18n/de.json

@@ -18,6 +18,7 @@
   "query_index.table.columns.entity": "Entität",
   "query_index.table.columns.fulltext": "Volltext",
   "query_index.table.columns.indexed": "Indexiert",
+  "query_index.table.columns.label": "Beschriftung",
   "query_index.table.columns.records": "Datensätze",
   "query_index.table.columns.status": "Status",
   "query_index.table.columns.vector": "Vektor",
@@ -34,10 +35,6 @@
   "query_index.table.errors.subtitle": "Die letzten 100 Fehler für Query- und Vektor-Indexer in diesem Bereich.",
   "query_index.table.errors.title": "Aktuelle Indexer-Fehler",
   "query_index.table.errors.viewDetails": "Technische Details anzeigen",
-  "query_index.table.filters.backend": "Backend",
-  "query_index.table.filters.backendOptions.customFields": "Benutzerdefinierte Felder",
-  "query_index.table.filters.backendOptions.fulltext": "Volltextsuche",
-  "query_index.table.filters.backendOptions.vector": "Vektorsuche",
   "query_index.table.logs.columns.message": "Nachricht",
   "query_index.table.logs.columns.source": "Quelle",
   "query_index.table.logs.columns.timestamp": "Zeitstempel",
@@ -51,7 +48,6 @@
   "query_index.table.searchPlaceholder": "Nach Entität filtern",
   "query_index.table.status.failed": "Fehlgeschlagen",
   "query_index.table.status.in_sync": "Synchron",
-  "query_index.table.status.not_measured": "Noch nicht gemessen",
   "query_index.table.status.out_of_sync": "Nicht synchron",
   "query_index.table.status.partitionLabel": "Partition {{index}}",
   "query_index.table.status.progress": "{{processed}}/{{total}}",
@@ -65,5 +61,7 @@
   "query_index.table.status.scope.stalled": "Angehalten",
   "query_index.table.status.scopeLabel": "Bereich",
   "query_index.table.status.stalled": "Angehalten",
+  "query_index.table.status.vectorLabel": "Vektor",
+  "query_index.table.status.vectorValue": "{{count}} / {{total}}",
   "query_index.table.status.withProgress": "{{status}} ({{progress}})"
 }