@open-mercato/core 0.6.7 → 0.6.8-develop.6874.1.982d6097d8

package/src/modules/query_index/cli.ts

@@ -11,7 +11,7 @@ type ProgressBarHandle = {
   update(completed: number): void
   complete(): void
 }
-import { resolveEntityTableName } from '@open-mercato/shared/lib/query/engine'
+import { resolveEntityTableName, resolveRegisteredEntityTableName } 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,6 +23,7 @@ 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'
 
@@ -340,6 +341,168 @@ 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) {
@@ -710,6 +873,14 @@ 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 },
           {
@@ -848,6 +1019,14 @@ 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,8 +1,10 @@
 "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'
@@ -52,15 +54,54 @@ 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()
@@ -83,15 +124,24 @@ function formatProgressLabel(
   return t('query_index.table.status.progressSingle', { processed: processedText })
 }
 
-function translateJobStatus(t: Translator, status: JobStatus['status'] | undefined, ok: boolean): string {
-  if (!status || status === 'idle') {
+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')
     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 ok ? t('query_index.table.status.in_sync') : t('query_index.table.status.out_of_sync')
+  return idleLabel()
 }
 
 function translateScopeStatus(
@@ -108,8 +158,15 @@ function translateScopeStatus(
 
 function createColumns(t: Translator): ColumnDef<Row>[] {
   return [
-    { 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: '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: 'baseCount',
       header: () => t('query_index.table.columns.records'),
@@ -127,10 +184,10 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
     {
       id: 'vectorCount',
       header: () => t('query_index.table.columns.vector'),
-      accessorFn: (row) => (row.vectorEnabled ? row.vectorCount ?? 0 : -1),
+      accessorFn: (row) => (isVectorReportable(row) ? row.vectorCount ?? 0 : -1),
       cell: ({ row }) => {
         const record = row.original
-        if (!record.vectorEnabled) return <span>—</span>
+        if (!isVectorReportable(record)) 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'
@@ -159,17 +216,45 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
         const record = row.original
         const job = record.job
         const partitions = job?.partitions ?? []
-        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 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 label = jobProgress
           ? t('query_index.table.status.withProgress', { status: statusText, progress: jobProgress })
           : statusText
         let variant: StatusBadgeVariant = 'neutral'
         if (job) {
-          if (job.status === 'stalled' || jobFailed) variant = 'error'
-          else if (job.status === 'reindexing' || job.status === 'purging') variant = 'warning'
+          if (effectiveStatus === 'stalled' || jobFailed) variant = 'error'
+          else if (effectiveStatus === 'reindexing' || effectiveStatus === 'purging') variant = 'warning'
           else variant = ok ? 'success' : 'neutral'
         } else {
           variant = ok ? 'success' : 'neutral'
@@ -177,33 +262,28 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
 
         const lines: string[] = []
 
-        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})` : ''}`)
+        // 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 (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}`)
+          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})` : ''}`)
+            }
+          }
         }
 
         return (
@@ -230,14 +310,27 @@ function createColumns(t: Translator): ColumnDef<Row>[] {
 
 export default function QueryIndexesTable() {
   const [sorting, setSorting] = React.useState<SortingState>([{ id: 'entityId', desc: false }])
-  const [page, setPage] = React.useState(1)
   const [search, setSearch] = React.useState('')
+  const [page, setPage] = React.useState(1)
+  const [filterValues, setFilterValues] = React.useState<FilterValues>({})
   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
@@ -263,11 +356,49 @@ export default function QueryIndexesTable() {
   })
 
   const rowsAll = data?.items || []
-  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 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 trigger = React.useCallback(
     async (action: 'reindex' | 'purge', entityId: string, opts?: { force?: boolean }) => {
@@ -416,10 +547,24 @@ 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={setSorting}
-        perspective={{ tableId: 'query_index.status.list' }}
+        onSortingChange={(next) => {
+          setSorting(next)
+          setPage(1)
+        }}
+        perspective={{ tableId: extensionPoints.hosts.statusTable.tableId }}
         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) },
@@ -436,6 +581,8 @@ 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(
               {
@@ -470,7 +617,7 @@ export default function QueryIndexesTable() {
 
           return <RowActions items={items} />
         }}
-        pagination={{ page, pageSize: 50, total: rows.length, totalPages: 1, onPageChange: setPage }}
+        pagination={pagination}
         isLoading={isLoading}
       />
       {ConfirmDialogElement}

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

@@ -255,6 +255,13 @@ 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,6 +4,7 @@ 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>'
@@ -65,6 +66,10 @@ 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
@@ -118,6 +123,7 @@ 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/events.ts

@@ -0,0 +1,17 @@
+import { createModuleEvents } from '@open-mercato/shared/modules/events'
+
+const events = [
+  { id: 'query_index.coverage.refresh', label: 'Coverage Refresh', category: 'lifecycle' },
+  { id: 'query_index.coverage.warmup', label: 'Coverage Warmup', category: 'lifecycle' },
+  { id: 'query_index.delete_one', label: 'Delete One', category: 'lifecycle' },
+  { id: 'query_index.purge', label: 'Purge', category: 'lifecycle' },
+  { id: 'query_index.reindex', label: 'Reindex', category: 'lifecycle' },
+  { id: 'query_index.upsert_one', label: 'Upsert One', category: 'lifecycle' },
+  { id: 'query_index.vectorize_one', label: 'Vectorize One', category: 'lifecycle' },
+  { id: 'query_index.vectorize_purge', label: 'Vectorize Purge', category: 'lifecycle' },
+] as const
+
+export const eventsConfig = createModuleEvents({ moduleId: 'query_index', events })
+export const emitQueryIndexEvent = eventsConfig.emit
+export type QueryIndexEventId = typeof events[number]['id']
+export default eventsConfig

package/src/modules/query_index/extension-points.ts

@@ -0,0 +1,10 @@
+import { dataTableExtensionHost, defineModuleExtensionPoints } from '@open-mercato/shared/modules/widgets/extension-points'
+
+export const extensionPoints = defineModuleExtensionPoints({
+  moduleId: 'query_index',
+  hosts: {
+    statusTable: dataTableExtensionHost({ tableId: 'query_index.status.list', source: 'components/QueryIndexesTable.tsx' }),
+  },
+})
+
+export default extensionPoints