@open-mercato/core 0.6.7-develop.6834.1.e76f4b8cbc → 0.6.7-develop.6851.1.c1680b00d8

package/src/modules/portal/i18n/ko.json

@@ -0,0 +1,143 @@
+{
+  "portal.dashboard.customize": "사용자 지정",
+  "portal.dashboard.done": "완료",
+  "portal.dashboard.email": "이메일",
+  "portal.dashboard.emailNotVerified": "인증되지 않음",
+  "portal.dashboard.emailVerified": "인증됨",
+  "portal.dashboard.emptyWidgets": "모듈이 portal:dashboard:sections 위치에 위젯을 삽입하면 이곳에 대시보드 위젯이 표시됩니다.",
+  "portal.dashboard.lastLogin": "마지막 로그인",
+  "portal.dashboard.logout": "로그아웃",
+  "portal.dashboard.memberSince": "가입일",
+  "portal.dashboard.never": "없음",
+  "portal.dashboard.noPermissions": "권한 없음",
+  "portal.dashboard.noRoles": "할당된 역할 없음",
+  "portal.dashboard.permissions": "권한",
+  "portal.dashboard.portalAdmin": "포털 관리자",
+  "portal.dashboard.profile": "프로필",
+  "portal.dashboard.roles": "역할",
+  "portal.dashboard.title": "대시보드",
+  "portal.dashboard.welcome": "{name}님, 환영합니다",
+  "portal.dashboard.widgets": "대시보드 위젯",
+  "portal.disabled.description": "관리자가 고객 포털을 비활성화했습니다. 자세한 내용은 소속 조직에 문의해 주세요.",
+  "portal.disabled.title": "포털을 사용할 수 없습니다",
+  "portal.footer.copyright": "© {year} 모든 권리 보유.",
+  "portal.info.instructions": "조직의 포털에 접속하려면 조직 고유의 URL로 이동하세요. 포털 링크를 모른다면 관리자에게 문의하세요.",
+  "portal.invite.backToLogin": "이미 계정이 있나요?",
+  "portal.invite.confirmPassword": "비밀번호 확인",
+  "portal.invite.confirmPassword.placeholder": "••••••••",
+  "portal.invite.description": "이 초대를 수락하려면 포털 계정을 만드세요.",
+  "portal.invite.displayName": "표시 이름",
+  "portal.invite.error.displayNameRequired": "표시 이름이 필요합니다.",
+  "portal.invite.error.generic": "초대 수락에 실패했습니다. 다시 시도해 주세요.",
+  "portal.invite.error.invalidToken": "초대가 유효하지 않거나 만료되었습니다.",
+  "portal.invite.error.noToken": "초대 토큰이 잘못되었거나 누락되었습니다.",
+  "portal.invite.error.passwordMismatch": "비밀번호가 일치하지 않습니다.",
+  "portal.invite.error.passwordTooShort": "비밀번호는 8자 이상이어야 합니다.",
+  "portal.invite.loginLink": "로그인",
+  "portal.invite.password": "비밀번호",
+  "portal.invite.password.placeholder": "••••••••",
+  "portal.invite.submit": "초대 수락",
+  "portal.invite.submitting": "초대를 수락하는 중…",
+  "portal.invite.title": "초대 수락",
+  "portal.landing.cta.login": "로그인",
+  "portal.landing.cta.signup": "계정 만들기",
+  "portal.landing.feature.account": "계정 관리",
+  "portal.landing.feature.account.description": "프로필을 업데이트하고, 팀원을 관리하고, 환경설정을 구성하세요.",
+  "portal.landing.feature.orders": "주문 및 인보이스",
+  "portal.landing.feature.orders.description": "주문을 추적하고, 인보이스를 다운로드하고, 배송 상태를 실시간으로 확인하세요.",
+  "portal.landing.feature.security": "안전한 접근",
+  "portal.landing.feature.security.description": "역할 기반 권한, 세션 관리, 전체 감사 추적 기능을 제공합니다.",
+  "portal.landing.hero.description": "계정을 관리하고, 주문을 확인하고, 모든 리소스를 한곳에서 이용하세요.",
+  "portal.landing.hero.title": "고객 포털에 오신 것을 환영합니다",
+  "portal.login.description": "고객 계정으로 로그인하세요.",
+  "portal.login.email": "이메일",
+  "portal.login.email.placeholder": "you@example.com",
+  "portal.login.error.generic": "로그인에 실패했습니다. 다시 시도해 주세요.",
+  "portal.login.error.inactive": "계정이 아직 활성화되지 않았습니다. 로그인하려면 관리자가 계정을 활성화해야 합니다.",
+  "portal.login.error.invalidCredentials": "이메일 또는 비밀번호가 올바르지 않습니다.",
+  "portal.login.error.locked": "계정이 일시적으로 잠겼습니다. 잠시 후 다시 시도해 주세요.",
+  "portal.login.noAccount": "계정이 없으신가요?",
+  "portal.login.password": "비밀번호",
+  "portal.login.password.placeholder": "비밀번호를 입력하세요",
+  "portal.login.signupLink": "가입하기",
+  "portal.login.submit": "로그인",
+  "portal.login.submitting": "로그인 중…",
+  "portal.login.title": "로그인",
+  "portal.nav.account": "계정",
+  "portal.nav.dashboard": "대시보드",
+  "portal.nav.home": "포털",
+  "portal.nav.invite": "초대 수락",
+  "portal.nav.login": "로그인",
+  "portal.nav.logout": "로그아웃",
+  "portal.nav.profile": "프로필",
+  "portal.nav.resetPassword": "비밀번호 재설정",
+  "portal.nav.signup": "회원가입",
+  "portal.notifications.badge": "읽지 않은 알림 {count}개",
+  "portal.notifications.daysAgo": "{d}일 전",
+  "portal.notifications.dismiss": "닫기",
+  "portal.notifications.empty": "아직 알림이 없습니다",
+  "portal.notifications.emptyUnread": "모두 확인했습니다!",
+  "portal.notifications.hoursAgo": "{h}시간 전",
+  "portal.notifications.justNow": "방금 전",
+  "portal.notifications.markAllRead": "모두 읽음으로 표시",
+  "portal.notifications.markRead": "읽음으로 표시",
+  "portal.notifications.minutesAgo": "{m}분 전",
+  "portal.notifications.tab.all": "전체",
+  "portal.notifications.tab.unread": "읽지 않음",
+  "portal.notifications.title": "알림",
+  "portal.notifications.unreadSummary": "읽지 않은 알림 {count}개",
+  "portal.notifications.view": "보기",
+  "portal.org.invalid": "조직을 찾을 수 없습니다. URL을 확인한 후 다시 시도해 주세요.",
+  "portal.org.loading": "조직 정보를 불러오는 중...",
+  "portal.org.noOrganization": "조직 정보를 사용할 수 없습니다.",
+  "portal.profile.label": "계정",
+  "portal.profile.title": "프로필",
+  "portal.resetPassword.backToLogin": "비밀번호가 기억나셨나요?",
+  "portal.resetPassword.confirmPassword": "새 비밀번호 확인",
+  "portal.resetPassword.confirmPassword.placeholder": "••••••••",
+  "portal.resetPassword.description": "아래에 새 비밀번호를 입력하세요.",
+  "portal.resetPassword.error.generic": "비밀번호 재설정에 실패했습니다. 다시 시도해 주세요.",
+  "portal.resetPassword.error.invalidToken": "재설정 토큰이 유효하지 않거나 만료되었습니다.",
+  "portal.resetPassword.error.noToken": "재설정 토큰이 유효하지 않거나 없습니다.",
+  "portal.resetPassword.error.passwordMismatch": "비밀번호가 일치하지 않습니다.",
+  "portal.resetPassword.error.passwordTooShort": "비밀번호는 8자 이상이어야 합니다.",
+  "portal.resetPassword.loginLink": "로그인",
+  "portal.resetPassword.password": "새 비밀번호",
+  "portal.resetPassword.password.placeholder": "••••••••",
+  "portal.resetPassword.submit": "비밀번호 재설정",
+  "portal.resetPassword.submitting": "비밀번호 재설정 중…",
+  "portal.resetPassword.success.description": "비밀번호가 성공적으로 재설정되었습니다.",
+  "portal.resetPassword.success.loginLink": "로그인하러 가기",
+  "portal.resetPassword.success.message": "이제 새 비밀번호로 로그인할 수 있습니다.",
+  "portal.resetPassword.success.title": "비밀번호 재설정 완료",
+  "portal.resetPassword.title": "비밀번호 재설정",
+  "portal.signup.description": "신규 고객 계정을 등록하세요.",
+  "portal.signup.displayName": "표시 이름",
+  "portal.signup.displayName.placeholder": "이름을 입력하세요",
+  "portal.signup.email": "이메일",
+  "portal.signup.email.placeholder": "you@example.com",
+  "portal.signup.error.displayName.required": "이름을 입력해 주세요.",
+  "portal.signup.error.email.invalid": "올바른 이메일 주소를 입력해 주세요.",
+  "portal.signup.error.generic": "가입에 실패했습니다. 다시 시도해 주세요.",
+  "portal.signup.error.password.minLength": "비밀번호는 8자 이상이어야 합니다.",
+  "portal.signup.hasAccount": "이미 계정이 있으신가요?",
+  "portal.signup.loginLink": "로그인",
+  "portal.signup.password": "비밀번호",
+  "portal.signup.password.placeholder": "안전한 비밀번호를 설정하세요",
+  "portal.signup.submit": "계정 만들기",
+  "portal.signup.submitting": "계정 생성 중…",
+  "portal.signup.success.description": "가입이 승인되었다면 로그인 전에 이메일에서 다음 단계를 확인하세요. 일부 조직에서는 관리자가 신규 계정을 활성화해야 합니다.",
+  "portal.signup.success.loginLink": "로그인하러 가기",
+  "portal.signup.success.title": "이메일을 확인하세요",
+  "portal.signup.title": "계정 만들기",
+  "portal.subtitle": "셀프서비스 허브",
+  "portal.title": "고객 포털",
+  "portal.verify.description": "이메일 주소를 확인하는 동안 잠시 기다려 주세요.",
+  "portal.verify.error.backToLogin": "로그인으로 돌아가기",
+  "portal.verify.error.generic": "이메일 인증에 실패했습니다. 다시 시도해 주세요.",
+  "portal.verify.error.invalidToken": "인증 토큰이 없습니다.",
+  "portal.verify.success.description": "이메일 인증이 완료되었습니다. 이제 포털에 로그인할 수 있습니다.",
+  "portal.verify.success.loginLink": "로그인",
+  "portal.verify.success.title": "이메일 인증 완료",
+  "portal.verify.title": "이메일 인증 중"
+}

package/src/modules/progress/i18n/ko.json

@@ -0,0 +1,20 @@
+{
+  "progress.actions.cancel": "취소",
+  "progress.actions.dismiss": "닫기",
+  "progress.actions.retry": "재시도",
+  "progress.activeCount": "{count}개 작업 실행 중",
+  "progress.errors.alreadyFinished": "작업이 이미 완료되었습니다",
+  "progress.errors.cannotCancel": "이 작업은 취소할 수 없습니다",
+  "progress.errors.notFound": "작업을 찾을 수 없습니다",
+  "progress.eta.hoursMinutes": "{hours}시간 {minutes}분 남음",
+  "progress.eta.minutes": "{count}분 남음",
+  "progress.eta.seconds": "{count}초 남음",
+  "progress.processed": "처리됨",
+  "progress.recentlyCompleted": "{count}개 작업 완료됨",
+  "progress.status.cancelled": "취소됨",
+  "progress.status.completed": "완료됨",
+  "progress.status.failed": "실패",
+  "progress.status.pending": "대기 중",
+  "progress.status.running": "실행 중",
+  "progress.title": "진행 상황"
+}

package/src/modules/query_index/api/reindex.ts

@@ -85,6 +85,21 @@ export async function POST(req: Request) {
       },
     },
   ).catch(() => undefined)
+  // Queued once here rather than from a partition: the purge deletes every vector for the
+  // scope, so emitting it from inside the fan-out would race the per-record vectorize jobs
+  // its siblings are already queueing and drop vectors this run had just rebuilt.
+  if (force && partitions.length > 1) {
+    try {
+      await bus.emitEvent(
+        'query_index.vectorize_purge',
+        { entityType, tenantId: auth.tenantId ?? null, organizationId: auth.orgId ?? null },
+        { persistent: true, deliverInline: false },
+      )
+    } catch {
+      // Best effort: a failed purge leaves stale vectors, which the orphan sweep still prunes.
+    }
+  }
+
   try {
     await Promise.all(
       partitions.map((part) => {

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/i18n/ko.json

@@ -0,0 +1,69 @@
+{
+  "query_index.banner.dismiss": "닫기",
+  "query_index.banner.manage_indexes": "인덱스 관리",
+  "query_index.banner.partial_counts": "{{total}}개 레코드 중 {{indexed}}개가 인덱싱되었습니다.",
+  "query_index.banner.partial_counts_excess": "현재 인덱스에 {{total}}개 레코드에 대해 {{indexed}}개 항목이 있습니다. 오래된 행을 정리하려면 재인덱싱하세요.",
+  "query_index.banner.partial_description": "쿼리 인덱스에서 부분적인 커버리지가 감지되었습니다. 모든 레코드를 새로 고치려면 재인덱싱하세요.",
+  "query_index.banner.partial_entity": "엔터티: {{entity}}",
+  "query_index.banner.partial_global_note": "다른 조직의 일부 레코드가 아직 인덱스에서 누락되어 있습니다.",
+  "query_index.banner.partial_title": "결과가 불완전할 수 있습니다",
+  "query_index.nav.queryIndexes": "쿼리 인덱스",
+  "query_index.table.actions.fulltextPurge": "전체 텍스트 검색 삭제",
+  "query_index.table.actions.fulltextReindex": "전체 텍스트 검색 재인덱싱",
+  "query_index.table.actions.purge": "삭제",
+  "query_index.table.actions.reindex": "재인덱싱",
+  "query_index.table.actions.reindexForce": "전체 재인덱싱 강제 실행",
+  "query_index.table.actions.vectorPurge": "벡터 검색 삭제",
+  "query_index.table.actions.vectorReindex": "벡터 검색 재인덱싱",
+  "query_index.table.columns.entity": "엔터티",
+  "query_index.table.columns.fulltext": "전체 텍스트",
+  "query_index.table.columns.indexed": "인덱싱됨",
+  "query_index.table.columns.records": "레코드",
+  "query_index.table.columns.status": "상태",
+  "query_index.table.columns.vector": "벡터",
+  "query_index.table.confirm.fulltextPurge": "이 엔터티의 전체 텍스트 인덱스를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
+  "query_index.table.confirm.vectorPurge": "이 엔터티의 벡터 임베딩을 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
+  "query_index.table.errors.actionFailed": "{{action}} 실행에 실패했습니다.",
+  "query_index.table.errors.columns.details": "상세 정보",
+  "query_index.table.errors.columns.source": "소스",
+  "query_index.table.errors.columns.timestamp": "타임스탬프",
+  "query_index.table.errors.empty": "최근 오류가 기록되지 않았습니다.",
+  "query_index.table.errors.loadFailed": "쿼리 인덱스 상태를 불러오지 못했습니다.",
+  "query_index.table.errors.scope.organization": "조직 {{organizationId}}",
+  "query_index.table.errors.scope.tenant": "테넌트 {{tenantId}}",
+  "query_index.table.errors.subtitle": "이 범위의 쿼리 인덱스 및 벡터 인덱스 작업에 대해 기록된 최근 100개 오류입니다.",
+  "query_index.table.errors.title": "최근 인덱서 오류",
+  "query_index.table.errors.viewDetails": "기술 상세 정보 보기",
+  "query_index.table.filters.backend": "백엔드",
+  "query_index.table.filters.backendOptions.customFields": "사용자 정의 필드",
+  "query_index.table.filters.backendOptions.fulltext": "전체 텍스트 검색",
+  "query_index.table.filters.backendOptions.vector": "벡터 검색",
+  "query_index.table.logs.columns.message": "메시지",
+  "query_index.table.logs.columns.source": "소스",
+  "query_index.table.logs.columns.timestamp": "타임스탬프",
+  "query_index.table.logs.empty": "최근 활동이 없습니다.",
+  "query_index.table.logs.level.info": "정보",
+  "query_index.table.logs.level.warn": "경고",
+  "query_index.table.logs.subtitle": "이 범위의 쿼리 인덱스 및 벡터 인덱스 작업에 대해 기록된 최근 100개 상태 로그입니다.",
+  "query_index.table.logs.title": "최근 인덱서 활동",
+  "query_index.table.logs.viewDetails": "상세 정보 보기",
+  "query_index.table.refresh": "새로고침",
+  "query_index.table.searchPlaceholder": "엔터티로 필터링",
+  "query_index.table.status.failed": "실패한",
+  "query_index.table.status.in_sync": "동기화됨",
+  "query_index.table.status.not_measured": "아직 측정되지 않음",
+  "query_index.table.status.out_of_sync": "동기화 안 됨",
+  "query_index.table.status.partitionLabel": "파티션 {{index}}",
+  "query_index.table.status.progress": "{{processed}}/{{total}}",
+  "query_index.table.status.progressSingle": "{{processed}}",
+  "query_index.table.status.purging": "삭제 중",
+  "query_index.table.status.reindexing": "재인덱싱 중",
+  "query_index.table.status.scope.completed": "완료",
+  "query_index.table.status.scope.failed": "실패한",
+  "query_index.table.status.scope.purging": "삭제 중",
+  "query_index.table.status.scope.reindexing": "실행 중",
+  "query_index.table.status.scope.stalled": "정체됨",
+  "query_index.table.status.scopeLabel": "범위",
+  "query_index.table.status.stalled": "정체됨",
+  "query_index.table.status.withProgress": "{{status}} ({{progress}})"
+}

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

@@ -294,6 +294,19 @@ export async function deleteCoverageForEntity(db: Kysely<any>, entityType: strin
     .execute()
 }
 
+async function deleteCoverageScope(db: Kysely<any>, scope: CoverageScope): Promise<void> {
+  const { entityType, tenantId, organizationId, withDeleted } = scope
+  if (!entityType) return
+  let query = db
+    .deleteFrom('entity_index_coverage' as any)
+    .where('entity_type' as any, '=', entityType)
+    .where('with_deleted' as any, '=', withDeleted === true)
+  query = tenantId == null
+    ? query.where('tenant_id' as any, 'is', null as any)
+    : query.where('tenant_id' as any, '=', tenantId)
+  await applyOrganizationCondition(query as any, 'organization_id', organizationId ?? null).execute()
+}
+
 async function tableHasColumn(db: Kysely<any>, table: string, column: string): Promise<boolean> {
   const key = `${table}.${column}`
   if (COLUMN_CACHE.has(key)) return COLUMN_CACHE.get(key)!
@@ -381,9 +394,9 @@ export async function primeColumnCache(db: Kysely<any>, checks: ColumnCheck[]):
 export async function refreshCoverageSnapshot(
   em: EntityManager,
   scope: CoverageScope,
-): Promise<void> {
+): Promise<{ baseCount: number; indexedCount: number } | null> {
   const entityType = String(scope.entityType || '')
-  if (!entityType) return
+  if (!entityType) return null
   const tenantId = scope.tenantId ?? null
   const organizationId = scope.organizationId ?? null
   const withDeleted = scope.withDeleted === true
@@ -395,22 +408,37 @@ export async function refreshCoverageSnapshot(
   const hasTenant = await tableHasColumn(db, baseTable, 'tenant_id')
   const hasDeleted = await tableHasColumn(db, baseTable, 'deleted_at')
 
-  if (organizationId !== null && !hasOrg) return
-  if (tenantId !== null && !hasTenant) return
+  // A scope the base table cannot express must not narrow the index side either. Index rows
+  // can carry an organization the base table has no column for — `organizations` has no
+  // `organization_id` yet its index rows derive one from the record id. Filtering only the
+  // index side compares two different populations and reports a gap no reindex can close;
+  // returning early instead of recounting left the previous snapshot frozen, which is what
+  // surfaced as a permanent "out of sync" row for `directory:organization`.
+  //
+  // Tenant is different: a base table without `tenant_id` (`user_roles`) cannot be counted
+  // per tenant at all, and writing the cross-tenant total into one tenant's row would leak
+  // another tenant's volume into it. Drop the unusable scoped row instead, leaving only the
+  // global row — which is the one that can be true — rather than freezing a stale count.
+  const scopeOrg = organizationId !== null && hasOrg
+  if (tenantId !== null && !hasTenant) {
+    await deleteCoverageScope(db, { entityType, tenantId, organizationId, withDeleted })
+    return null
+  }
+  const scopeTenant = tenantId !== null && hasTenant
 
   let baseQuery = db
     .selectFrom(`${baseTable} as b` as any)
     .select(sql`count(*)`.as('count'))
-  if (organizationId !== null && hasOrg) baseQuery = baseQuery.where('b.organization_id' as any, '=', organizationId)
-  if (tenantId !== null && hasTenant) baseQuery = baseQuery.where('b.tenant_id' as any, '=', tenantId)
+  if (scopeOrg) baseQuery = baseQuery.where('b.organization_id' as any, '=', organizationId)
+  if (scopeTenant) baseQuery = baseQuery.where('b.tenant_id' as any, '=', tenantId)
   if (!withDeleted && hasDeleted) baseQuery = baseQuery.where('b.deleted_at' as any, 'is', null as any)
 
   let indexQuery = db
     .selectFrom('entity_indexes as ei' as any)
     .select(sql`count(*)`.as('count'))
     .where('ei.entity_type' as any, '=', entityType)
-  if (organizationId !== null) indexQuery = indexQuery.where('ei.organization_id' as any, '=', organizationId)
-  if (tenantId !== null) indexQuery = indexQuery.where('ei.tenant_id' as any, '=', tenantId)
+  if (scopeOrg) indexQuery = indexQuery.where('ei.organization_id' as any, '=', organizationId)
+  if (scopeTenant) indexQuery = indexQuery.where('ei.tenant_id' as any, '=', tenantId)
   if (!withDeleted) indexQuery = indexQuery.where('ei.deleted_at' as any, 'is', null as any)
 
   const vectorCountPromise = (async (): Promise<number | undefined> => {
@@ -453,6 +481,8 @@ export async function refreshCoverageSnapshot(
     indexedCount: indexCount,
     vectorCount,
   })
+
+  return { baseCount, indexedCount: indexCount }
 }
 
 export async function writeCoverageCounts(