@open-mercato/core 0.6.5-develop.4674.1.bf258550ce → 0.6.5-develop.4695.1.42ee0ddf0e

package/src/modules/customers/commands/deals.ts

@@ -9,6 +9,7 @@ import {
   normalizeAuthorUserId,
 } from '@open-mercato/shared/lib/commands/helpers'
 import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
+import { runCrudCommandWrite } from '@open-mercato/shared/lib/commands/runCrudCommandWrite'
 import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import {
@@ -569,120 +570,114 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
     let nextPipelineStageLabel: string | null = null
     let resolvedCurrentPipelineStageLabel: string | null = null
 
-    await withAtomicFlush(em, [
-      async () => {
-        const pipelineAssignmentChanged =
-          parsed.pipelineId !== undefined || parsed.pipelineStageId !== undefined
-        const requestedPipelineStageId =
-          parsed.pipelineStageId !== undefined
-            ? parsed.pipelineStageId ?? null
-            : record.pipelineStageId ?? null
-        const requestedPipelineId =
-          parsed.pipelineId !== undefined ? parsed.pipelineId ?? null : record.pipelineId ?? null
-
-        nextStageSnapshot = requestedPipelineStageId && (pipelineAssignmentChanged || !record.pipelineStage)
-          ? await loadPipelineStageSnapshot(em, requestedPipelineStageId, record.tenantId, record.organizationId)
-          : null
-        if (pipelineAssignmentChanged) {
-          nextPipelineAssignment = resolvePipelineAssignment({
-            pipelineId: requestedPipelineId,
-            pipelineStageId: requestedPipelineStageId,
-            stageSnapshot: nextStageSnapshot,
-          })
-        }
-        nextPipelineStageLabel = nextStageSnapshot
-          ? (await ensureDictionaryEntry(em, {
-            tenantId: record.tenantId,
-            organizationId: record.organizationId,
-            kind: 'pipeline_stage',
-            value: nextStageSnapshot.label,
-          }))?.value ?? nextStageSnapshot.label
-          : null
-        resolvedCurrentPipelineStageLabel =
-          !nextStageSnapshot && record.pipelineStageId && (parsed.pipelineStageId !== undefined || !record.pipelineStage)
-            ? await resolvePipelineStageValue(em, record.pipelineStageId, record.tenantId, record.organizationId)
-            : null
-      },
-      () => {
-        if (parsed.title !== undefined) record.title = parsed.title
-        if (parsed.description !== undefined) record.description = parsed.description ?? null
-        if (parsed.status !== undefined) record.status = parsed.status ?? record.status
-        if (parsed.pipelineStage !== undefined) record.pipelineStage = parsed.pipelineStage ?? null
-        if (parsed.pipelineId !== undefined || (parsed.pipelineStageId !== undefined && nextStageSnapshot)) {
-          record.pipelineId = nextPipelineAssignment.pipelineId
-        }
-        if (parsed.pipelineStageId !== undefined) record.pipelineStageId = nextPipelineAssignment.pipelineStageId
-
-        if (nextPipelineStageLabel && (parsed.pipelineStageId !== undefined || !record.pipelineStage)) {
-          record.pipelineStage = nextPipelineStageLabel
-        } else if (resolvedCurrentPipelineStageLabel && (parsed.pipelineStageId !== undefined || !record.pipelineStage)) {
-          record.pipelineStage = resolvedCurrentPipelineStageLabel
-        }
-
-        if (parsed.valueAmount !== undefined) record.valueAmount = toNumericString(parsed.valueAmount)
-        if (parsed.valueCurrency !== undefined) record.valueCurrency = parsed.valueCurrency ?? null
-        if (parsed.probability !== undefined) record.probability = parsed.probability ?? null
-        if (parsed.expectedCloseAt !== undefined) record.expectedCloseAt = parsed.expectedCloseAt ?? null
-        if (parsed.ownerUserId !== undefined) record.ownerUserId = parsed.ownerUserId ?? null
-        if (parsed.source !== undefined) record.source = parsed.source ?? null
-        if (parsed.closureOutcome !== undefined) record.closureOutcome = parsed.closureOutcome ?? null
-        if (parsed.lossReasonId !== undefined) record.lossReasonId = parsed.lossReasonId ?? null
-        if (parsed.lossNotes !== undefined) record.lossNotes = parsed.lossNotes ?? null
-      },
-      async () => {
-        // CRITICAL: persist the scalar mutations above before any further `em.findOne` / sync
-        // helpers run inside this transaction. MikroORM v7's identity-map silently discards
-        // pending scalar changes on `record` if a query (such as the stage-transition lookup
-        // inside `upsertDealStageTransition`, or the linked-entity finds inside
-        // `syncDealPeople` / `syncDealCompanies`) executes on the same `EntityManager`
-        // before we explicitly flush. Without this flush, the entire kanban drag-and-drop
-        // returns 200 OK but never actually updates `customer_deals` rows — the card
-        // snaps back to its source lane on the next refetch (see SPEC-018).
-        await em.flush()
-      },
-      async () => {
-        const snapshot = nextStageSnapshot
-        if (!snapshot) return
-        const shouldRecord =
-          parsed.pipelineStageId !== undefined &&
-          parsed.pipelineStageId !== null &&
-          parsed.pipelineStageId !== previousPipelineStageId
-        if (!shouldRecord) return
-        await upsertDealStageTransition(em, {
-          deal: record,
-          pipelineId: snapshot.pipelineId,
-          stageId: snapshot.id,
-          stageLabel: nextPipelineStageLabel ?? snapshot.label,
-          stageOrder: snapshot.order,
-          transitionedByUserId: normalizedTransitionAuthorUserId,
-        })
-      },
-      () => syncDealPeople(em, record, parsed.personIds),
-      () => syncDealCompanies(em, record, parsed.companyIds),
-    ], { transaction: true })
-
-    const de = (ctx.container.resolve('dataEngine') as DataEngine)
-    await setCustomFieldsIfAny({
-      dataEngine: de,
+    await runCrudCommandWrite({
+      ctx,
+      em,
       entityId: DEAL_ENTITY_ID,
-      recordId: record.id,
-      organizationId: record.organizationId,
-      tenantId: record.tenantId,
-      values: custom,
-      notify: false,
-    })
-
-    await emitCrudSideEffects({
-      dataEngine: de,
       action: 'updated',
-      entity: record,
-      identifiers: {
-        id: record.id,
-        organizationId: record.organizationId,
-        tenantId: record.tenantId,
-      },
-      indexer: dealCrudIndexer,
+      scope: { tenantId: record.tenantId, organizationId: record.organizationId },
+      customFields: custom,
       events: dealCrudEvents,
+      indexer: dealCrudIndexer,
+      sideEffect: () => ({
+        entity: record,
+        identifiers: {
+          id: record.id,
+          organizationId: record.organizationId,
+          tenantId: record.tenantId,
+        },
+      }),
+      phases: [
+        async () => {
+          const pipelineAssignmentChanged =
+            parsed.pipelineId !== undefined || parsed.pipelineStageId !== undefined
+          const requestedPipelineStageId =
+            parsed.pipelineStageId !== undefined
+              ? parsed.pipelineStageId ?? null
+              : record.pipelineStageId ?? null
+          const requestedPipelineId =
+            parsed.pipelineId !== undefined ? parsed.pipelineId ?? null : record.pipelineId ?? null
+
+          nextStageSnapshot = requestedPipelineStageId && (pipelineAssignmentChanged || !record.pipelineStage)
+            ? await loadPipelineStageSnapshot(em, requestedPipelineStageId, record.tenantId, record.organizationId)
+            : null
+          if (pipelineAssignmentChanged) {
+            nextPipelineAssignment = resolvePipelineAssignment({
+              pipelineId: requestedPipelineId,
+              pipelineStageId: requestedPipelineStageId,
+              stageSnapshot: nextStageSnapshot,
+            })
+          }
+          nextPipelineStageLabel = nextStageSnapshot
+            ? (await ensureDictionaryEntry(em, {
+              tenantId: record.tenantId,
+              organizationId: record.organizationId,
+              kind: 'pipeline_stage',
+              value: nextStageSnapshot.label,
+            }))?.value ?? nextStageSnapshot.label
+            : null
+          resolvedCurrentPipelineStageLabel =
+            !nextStageSnapshot && record.pipelineStageId && (parsed.pipelineStageId !== undefined || !record.pipelineStage)
+              ? await resolvePipelineStageValue(em, record.pipelineStageId, record.tenantId, record.organizationId)
+              : null
+        },
+        () => {
+          if (parsed.title !== undefined) record.title = parsed.title
+          if (parsed.description !== undefined) record.description = parsed.description ?? null
+          if (parsed.status !== undefined) record.status = parsed.status ?? record.status
+          if (parsed.pipelineStage !== undefined) record.pipelineStage = parsed.pipelineStage ?? null
+          if (parsed.pipelineId !== undefined || (parsed.pipelineStageId !== undefined && nextStageSnapshot)) {
+            record.pipelineId = nextPipelineAssignment.pipelineId
+          }
+          if (parsed.pipelineStageId !== undefined) record.pipelineStageId = nextPipelineAssignment.pipelineStageId
+
+          if (nextPipelineStageLabel && (parsed.pipelineStageId !== undefined || !record.pipelineStage)) {
+            record.pipelineStage = nextPipelineStageLabel
+          } else if (resolvedCurrentPipelineStageLabel && (parsed.pipelineStageId !== undefined || !record.pipelineStage)) {
+            record.pipelineStage = resolvedCurrentPipelineStageLabel
+          }
+
+          if (parsed.valueAmount !== undefined) record.valueAmount = toNumericString(parsed.valueAmount)
+          if (parsed.valueCurrency !== undefined) record.valueCurrency = parsed.valueCurrency ?? null
+          if (parsed.probability !== undefined) record.probability = parsed.probability ?? null
+          if (parsed.expectedCloseAt !== undefined) record.expectedCloseAt = parsed.expectedCloseAt ?? null
+          if (parsed.ownerUserId !== undefined) record.ownerUserId = parsed.ownerUserId ?? null
+          if (parsed.source !== undefined) record.source = parsed.source ?? null
+          if (parsed.closureOutcome !== undefined) record.closureOutcome = parsed.closureOutcome ?? null
+          if (parsed.lossReasonId !== undefined) record.lossReasonId = parsed.lossReasonId ?? null
+          if (parsed.lossNotes !== undefined) record.lossNotes = parsed.lossNotes ?? null
+        },
+        async () => {
+          // CRITICAL: persist the scalar mutations above before any further `em.findOne` / sync
+          // helpers run inside this transaction. MikroORM v7's identity-map silently discards
+          // pending scalar changes on `record` if a query (such as the stage-transition lookup
+          // inside `upsertDealStageTransition`, or the linked-entity finds inside
+          // `syncDealPeople` / `syncDealCompanies`) executes on the same `EntityManager`
+          // before we explicitly flush. Without this flush, the entire kanban drag-and-drop
+          // returns 200 OK but never actually updates `customer_deals` rows — the card
+          // snaps back to its source lane on the next refetch (see SPEC-018).
+          await em.flush()
+        },
+        async () => {
+          const snapshot = nextStageSnapshot
+          if (!snapshot) return
+          const shouldRecord =
+            parsed.pipelineStageId !== undefined &&
+            parsed.pipelineStageId !== null &&
+            parsed.pipelineStageId !== previousPipelineStageId
+          if (!shouldRecord) return
+          await upsertDealStageTransition(em, {
+            deal: record,
+            pipelineId: snapshot.pipelineId,
+            stageId: snapshot.id,
+            stageLabel: nextPipelineStageLabel ?? snapshot.label,
+            stageOrder: snapshot.order,
+            transitionedByUserId: normalizedTransitionAuthorUserId,
+          })
+        },
+        () => syncDealPeople(em, record, parsed.personIds),
+        () => syncDealCompanies(em, record, parsed.companyIds),
+      ],
     })
 
     // Emit a lifecycle event for deal won/lost status changes; the notifications

package/src/modules/entities/lib/helpers.ts

@@ -118,6 +118,30 @@ export async function setRecordCustomFields(
     throw new Error(TOO_MANY_CUSTOM_FIELDS_ERROR)
   }
 
+  // Run the per-key delete+insert work inside ONE database transaction so a
+  // multi-value replacement is atomic and isolated. The array branch deletes the
+  // existing rows for a key and inserts the replacements; without an enclosing
+  // transaction those can land in separate commit boundaries under MikroORM's
+  // FlushMode.AUTO (a query elsewhere in the unit auto-flushes part of the work),
+  // which intermittently left the field with the delete applied but the inserts
+  // missing — the multi-select EDIT reverted to []. The single commit below makes
+  // it all-or-nothing. We only open our own transaction when the caller has not
+  // already started one (commands fork the request em and may run setCustomFields
+  // outside their own withAtomicFlush tx); join an ambient transaction otherwise.
+  const txEm = em as {
+    begin?: () => Promise<void>
+    commit?: () => Promise<void>
+    rollback?: () => Promise<void>
+    isInTransaction?: () => boolean
+  }
+  const txCapable =
+    typeof txEm.begin === 'function' &&
+    typeof txEm.commit === 'function' &&
+    typeof txEm.rollback === 'function' &&
+    typeof txEm.isInTransaction === 'function'
+  const ownCustomFieldTransaction = txCapable && !txEm.isInTransaction!()
+  if (ownCustomFieldTransaction) await txEm.begin!()
+  try {
   for (const fieldKey of keys) {
     const raw = values[fieldKey]
     if (raw === undefined) continue
@@ -125,10 +149,19 @@ export async function setRecordCustomFields(
     const def = defsByKey?.[fieldKey]
     const encrypted = Boolean(def?.configJson && (def as any).configJson?.encrypted)
     const isArray = Array.isArray(raw)
-    // When array: remove existing values for key and create multiple rows
+    // When array (multi-value): replace all existing rows for the key. The old
+    // rows are removed via em.remove (a DEFERRED delete keyed by primary id),
+    // not nativeDelete, so the DELETE and the replacement INSERTs are applied in
+    // the SAME em.flush() — MikroORM wraps a flush in one transaction, making the
+    // replacement atomic (the field can never be left empty by a partial
+    // failure between delete and insert). It also removes the FlushMode.AUTO
+    // footgun the old code had: a nativeDelete issued after em.create()
+    // auto-flushed the new rows and then deleted them by fieldKey, wiping the
+    // value on EDIT. Regression: TC-CAT-CF-MULTI-EDIT-001 / TC-CRM-CF-MULTI-EDIT-001.
     if (isArray) {
       const arr = raw as Primitive[]
-      const replacements: CustomFieldValue[] = []
+      const existing = await em.find(CustomFieldValue, { entityId, recordId, organizationId, tenantId, fieldKey })
+      for (const stale of existing) em.remove(stale)
       for (const val of arr) {
         const col: keyof CustomFieldValue = encrypted ? 'valueText' : def ? columnFromKind(def.kind) : columnFromJsValue(val)
         const cf = em.create(CustomFieldValue, { entityId, recordId, organizationId, tenantId, fieldKey, createdAt: new Date() })
@@ -144,10 +177,8 @@ export async function setRecordCustomFields(
           case 'valueBool': cf.valueBool = stored == null ? null : Boolean(stored); break
           default: cf.valueText = stored == null ? null : String(stored); break
         }
-        replacements.push(cf)
+        toPersist.push(cf)
       }
-      await em.nativeDelete(CustomFieldValue, { entityId, recordId, organizationId, tenantId, fieldKey })
-      toPersist.push(...replacements)
       continue
     }
 
@@ -186,24 +217,15 @@ export async function setRecordCustomFields(
 
   if (toPersist.length) em.persist(toPersist)
   await em.flush()
-  if (process.env.OM_CF_DEBUG) {
-    try {
-      const conn = em.getConnection()
-      for (const fieldKey of keys) {
-        if (values[fieldKey] === undefined) continue
-        const rows = await conn.execute(
-          'select value_text, value_multiline, value_int, value_float, value_bool from custom_field_values where entity_id = ? and record_id = ? and field_key = ? and ((organization_id is null and ? is null) or organization_id = ?) and ((tenant_id is null and ? is null) or tenant_id = ?)',
-          [entityId, recordId, fieldKey, organizationId, organizationId, tenantId, tenantId],
-          'all',
-        ) as Array<Record<string, unknown>>
-        const persisted = rows.map((row) => row.value_text ?? row.value_multiline ?? row.value_int ?? row.value_float ?? row.value_bool)
-        console.warn(`[CF_DEBUG] setRecordCustomFields entityId=${entityId} recordId=${recordId} fieldKey=${fieldKey} input=${JSON.stringify(values[fieldKey])} persistedRows=${rows.length} persisted=${JSON.stringify(persisted)}`)
-      }
-    } catch (err) {
-      console.warn(`[CF_DEBUG] re-query failed: ${(err as Error)?.message ?? String(err)}`)
+    if (ownCustomFieldTransaction) await txEm.commit!()
+  } catch (err) {
+    if (ownCustomFieldTransaction) {
+      try { await txEm.rollback!() } catch { /* surface the original error, not a rollback failure */ }
     }
+    throw err
   }
-  // Emit hook for indexing if requested (outside CRUD flows)
+  // Emit hook for indexing if requested (outside CRUD flows). Runs AFTER the
+  // transaction commits so consumers observe the persisted rows.
   try {
     if (typeof opts.onChanged === 'function') {
       await opts.onChanged({ entityId, recordId, organizationId, tenantId })

package/src/modules/query_index/lib/indexer.ts

@@ -158,7 +158,7 @@ function scopeEntityIndexes<QB extends { where: (...args: any[]) => QB }>(
 
 export async function upsertIndexRow(
   em: EntityManager,
-  args: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null; searchTokenDoc?: Record<string, unknown> | null }
+  args: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null; searchTokenDoc?: Record<string, unknown> | null; deferSearchTokens?: boolean }
 ): Promise<UpsertIndexResult> {
   const db = (em as any).getKysely()
 
@@ -172,14 +172,19 @@ export async function upsertIndexRow(
 
   const doc = await buildIndexDoc(em, args)
   if (!doc) {
-    try {
-      await deleteSearchTokensForRecord(db, {
-        entityType: args.entityType,
-        recordId: args.recordId,
-        organizationId: args.organizationId ?? null,
-        tenantId: args.tenantId ?? null,
-      })
-    } catch {}
+    // When the caller defers token work it owns the matching token cleanup; the
+    // projection-row removal below stays synchronous so list reads converge immediately.
+    if (!args.deferSearchTokens) {
+      try {
+        await reindexSearchTokensForRecord(em, {
+          entityType: args.entityType,
+          recordId: args.recordId,
+          organizationId: args.organizationId ?? null,
+          tenantId: args.tenantId ?? null,
+          doc: null,
+        })
+      } catch {}
+    }
     if (existed) {
       await scopeEntityIndexes(
         db.deleteFrom('entity_indexes' as any) as any,
@@ -233,27 +238,69 @@ export async function upsertIndexRow(
 
   const created = !existed
   const revived = existed && wasDeleted
-  try {
-    const tokenDoc = args.searchTokenDoc ?? (() => {
-      const encryption = resolveTenantEncryptionService(em as any)
-      const dekKeyCache = new Map<string | null, string | null>()
-      return decryptIndexDocForSearch(
-        args.entityType,
+  // The search-token rebuild (DELETE + chunked INSERT) is the heavy tail of indexing.
+  // Callers that defer it (the upsert subscriber) run `reindexSearchTokensForRecord`
+  // asynchronously after this projection update so write latency stays bounded.
+  if (!args.deferSearchTokens) {
+    try {
+      await reindexSearchTokensForRecord(em, {
+        entityType: args.entityType,
+        recordId: args.recordId,
+        organizationId: args.organizationId ?? null,
+        tenantId: args.tenantId ?? null,
         doc,
-        { tenantId: args.tenantId ?? null, organizationId: args.organizationId ?? null },
-        encryption,
-        dekKeyCache,
-      )
-    })()
-    await replaceSearchTokensForRecord(db, {
+        searchTokenDoc: args.searchTokenDoc ?? null,
+      })
+    } catch {}
+  }
+  return { doc, existed, wasDeleted, created, revived }
+}
+
+/**
+ * Rebuilds (or clears, when `doc` is null) the search-token rows for a single record.
+ * This is the asynchronous-friendly tail of `upsertIndexRow`: it does not touch the
+ * `entity_indexes` projection that list endpoints read, so it can run out-of-band
+ * without making query-index reads inconsistent.
+ */
+export async function reindexSearchTokensForRecord(
+  em: EntityManager,
+  args: {
+    entityType: string
+    recordId: string
+    organizationId?: string | null
+    tenantId?: string | null
+    doc: Record<string, any> | null
+    searchTokenDoc?: Record<string, unknown> | null
+  },
+): Promise<void> {
+  const db = (em as any).getKysely()
+  if (!args.doc) {
+    await deleteSearchTokensForRecord(db, {
       entityType: args.entityType,
       recordId: args.recordId,
       organizationId: args.organizationId ?? null,
       tenantId: args.tenantId ?? null,
-      doc: await tokenDoc,
     })
-  } catch {}
-  return { doc, existed, wasDeleted, created, revived }
+    return
+  }
+  const tokenDoc = args.searchTokenDoc ?? (() => {
+    const encryption = resolveTenantEncryptionService(em as any)
+    const dekKeyCache = new Map<string | null, string | null>()
+    return decryptIndexDocForSearch(
+      args.entityType,
+      args.doc,
+      { tenantId: args.tenantId ?? null, organizationId: args.organizationId ?? null },
+      encryption,
+      dekKeyCache,
+    )
+  })()
+  await replaceSearchTokensForRecord(db, {
+    entityType: args.entityType,
+    recordId: args.recordId,
+    organizationId: args.organizationId ?? null,
+    tenantId: args.tenantId ?? null,
+    doc: await tokenDoc,
+  })
 }
 
 export async function markDeleted(

package/src/modules/query_index/subscribers/delete_one.ts

@@ -8,7 +8,11 @@ import { loadQueryIndexRowScope, resolveQueryIndexRecordScope } from '../lib/sub
 export const metadata = { event: 'query_index.delete_one', persistent: false }
 
 export default async function handle(payload: any, ctx: { resolve: <T=any>(name: string) => T }) {
-  const em = ctx.resolve<any>('em')
+  // Forked EntityManager — this awaited subscriber runs synchronously on the request
+  // `em`; isolating it prevents our queries/writes from resetting the originating CRUD
+  // write's UnitOfWork and dropping its pending changes. See upsert_one.ts for detail.
+  const baseEm = ctx.resolve<any>('em')
+  const em = typeof baseEm?.fork === 'function' ? baseEm.fork() : baseEm
   const entityType = String(payload?.entityType || '')
   const recordId = String(payload?.recordId || '')
   if (!entityType || !recordId) return
@@ -73,24 +77,40 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
       }
     }
 
+    // The projection row + token removal above are synchronous (the data engine
+    // awaits this subscriber) so list reads are consistent immediately. The coverage
+    // recompute (a COUNT, run inline when delayMs is 0) and the fulltext delete are
+    // secondary, so defer them fire-and-forget to keep write/bulk-delete latency bounded.
     const shouldRefreshCoverage = coverageDelayMs === undefined || coverageDelayMs >= 0
-    if (shouldRefreshCoverage) {
-      const delay = coverageDelayMs ?? 0
+    const coverageRefreshDelay = coverageDelayMs ?? 0
+    void (async () => {
       try {
         const bus = ctx.resolve<any>('eventBus')
-        await bus.emitEvent('query_index.coverage.refresh', {
-          entityType,
-          tenantId: tenantId ?? null,
-          organizationId: organizationId ?? null,
-          delayMs: delay,
-        })
-      } catch {}
-    }
-    // Emit search delete event
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('search.delete_record', { entityId: entityType, recordId, organizationId, tenantId })
-    } catch {}
+        if (shouldRefreshCoverage) {
+          await bus.emitEvent('query_index.coverage.refresh', {
+            entityType,
+            tenantId: tenantId ?? null,
+            organizationId: organizationId ?? null,
+            delayMs: coverageRefreshDelay,
+          })
+        }
+        await bus.emitEvent('search.delete_record', { entityId: entityType, recordId, organizationId, tenantId })
+      } catch (error) {
+        await recordIndexerError(
+          { em },
+          {
+            source: 'query_index',
+            handler: 'event:query_index.delete_one:coverage_search',
+            error,
+            entityType,
+            recordId,
+            tenantId: tenantId ?? null,
+            organizationId: organizationId ?? null,
+            payload,
+          },
+        ).catch(() => {})
+      }
+    })()
   } catch (error) {
     await recordIndexerError(
       { em },

package/src/modules/query_index/subscribers/upsert_one.ts

@@ -1,12 +1,20 @@
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
-import { upsertIndexRow } from '../lib/indexer'
+import { upsertIndexRow, reindexSearchTokensForRecord } from '../lib/indexer'
 import { applyCoverageAdjustments, createCoverageAdjustments } from '../lib/coverage'
 import { loadQueryIndexRowScope, resolveQueryIndexRecordScope } from '../lib/subscriber-scope'
 
 export const metadata = { event: 'query_index.upsert_one', persistent: false }
 
 export default async function handle(payload: any, ctx: { resolve: <T=any>(name: string) => T }) {
-  const em = ctx.resolve<any>('em')
+  // Run index maintenance on a FORKED EntityManager (fresh identity map + UnitOfWork)
+  // so it can never disturb the originating CRUD write's `em`. The data engine awaits
+  // this emit for read-your-writes consistency, which means the subscriber runs
+  // synchronously on the request `em`; sharing it would let our `em.find` / raw
+  // `getKysely()` queries reset the caller's UoW change-tracking and silently drop the
+  // caller's pending write (e.g. the deal's `setCustomFields` insert). The fork reads
+  // the same committed DB rows via the shared connection but keeps its own UoW.
+  const baseEm = ctx.resolve<any>('em')
+  const em = typeof baseEm?.fork === 'function' ? baseEm.fork() : baseEm
   const entityType = String(payload?.entityType || '')
   const recordId = String(payload?.recordId || '')
   if (!entityType || !recordId) return
@@ -28,14 +36,18 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
     organizationId = resolvedScope.organizationId
     tenantId = resolvedScope.tenantId
 
+    const searchTokenDoc = typeof payload?.searchTokenDoc === 'object' && payload.searchTokenDoc && !Array.isArray(payload.searchTokenDoc)
+      ? (payload.searchTokenDoc as Record<string, unknown>)
+      : null
+    // Update the projection row synchronously so list reads (`customValues`) are
+    // consistent the moment the write returns; defer the heavy search-token rebuild.
     const result = await upsertIndexRow(em, {
       entityType,
       recordId,
       organizationId,
       tenantId,
-      searchTokenDoc: typeof payload?.searchTokenDoc === 'object' && payload.searchTokenDoc && !Array.isArray(payload.searchTokenDoc)
-        ? payload.searchTokenDoc
-        : null,
+      searchTokenDoc,
+      deferSearchTokens: true,
     })
     if (!suppressCoverage) {
       const doc = result.doc
@@ -84,16 +96,33 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
         } catch {}
       }
     }
-    // Kick off secondary pass (vectorize) asynchronously
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('query_index.vectorize_one', { entityType, recordId, organizationId, tenantId })
-    } catch {}
-    // Emit search indexing event
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('search.index_record', { entityId: entityType, recordId, organizationId, tenantId })
-    } catch {}
+    // Defer the heavy, eventually-consistent tail: search-token rebuild + vectorize +
+    // fulltext indexing. The data engine awaits this subscriber for projection
+    // consistency, so this work runs fire-and-forget to keep write latency bounded.
+    const deferredScope = { entityType, recordId, organizationId, tenantId }
+    const resolvedDoc = result.doc
+    void (async () => {
+      try {
+        await reindexSearchTokensForRecord(em, { ...deferredScope, doc: resolvedDoc, searchTokenDoc })
+        const bus = ctx.resolve<any>('eventBus')
+        await bus.emitEvent('query_index.vectorize_one', deferredScope)
+        await bus.emitEvent('search.index_record', { entityId: entityType, recordId, organizationId, tenantId })
+      } catch (error) {
+        await recordIndexerError(
+          { em },
+          {
+            source: 'query_index',
+            handler: 'event:query_index.upsert_one:search_tokens',
+            error,
+            entityType,
+            recordId,
+            tenantId: tenantId ?? null,
+            organizationId: organizationId ?? null,
+            payload,
+          },
+        ).catch(() => {})
+      }
+    })()
   } catch (error) {
     await recordIndexerError(
       { em },

package/src/modules/resources/backend/resources/resources/[id]/page.tsx

@@ -85,6 +85,13 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
   const searchParams = useSearchParams()
   const [initialValues, setInitialValues] = React.useState<Record<string, unknown> | null>(null)
   const [isNotFound, setIsNotFound] = React.useState(false)
+  // Capture the record (incl. its optimistic-lock `updatedAt`) exactly ONCE per
+  // resource. The load effect's deps include identity-unstable values (`t`,
+  // `resolveFieldsetCode`), so without this guard a re-render would re-fetch and
+  // overwrite `initialValues.updatedAt` with a newer server value mid-edit —
+  // silently defeating optimistic locking (a concurrent change would no longer be
+  // detected) and making the conflict flaky.
+  const loadedResourceIdRef = React.useRef<string | null>(null)
   const [tags, setTags] = React.useState<TagOption[]>([])
   const [activeTab, setActiveTab] = React.useState<'details' | 'availability'>('details')
   const [activeDetailTab, setActiveDetailTab] = React.useState<'notes' | 'activities'>('notes')
@@ -413,6 +420,9 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
 
   React.useEffect(() => {
     if (!resourceId || !resourceTypesLoaded) return
+    // Load once per resource — never re-fetch (and thereby refresh the captured
+    // optimistic-lock token) on subsequent re-renders. See loadedResourceIdRef.
+    if (loadedResourceIdRef.current === resourceId) return
     setIsNotFound(false)
     let cancelled = false
     async function loadResource() {
@@ -429,6 +439,7 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
           return
         }
         if (!cancelled) {
+          loadedResourceIdRef.current = resourceId ?? null
           const customValues = extractCustomFieldEntries(resource)
           setTags(Array.isArray(resource.tags) ? resource.tags : [])
           setAvailabilityRuleSetId(