@dzhechkov/harness-core 0.8.30 → 0.8.31

package/src/sqlite-read-helpers.ts

@@ -0,0 +1,128 @@
+/**
+ * Small, shared helpers for the READ-ONLY sqlite paths (`book-kb.ts`, `agentdb-index.ts`,
+ * `patterns.ts`) — feature `readonly-residuals`.
+ *
+ * Two residuals fixed here (`features/readonly-residuals/01_requirements.md`):
+ *
+ * FR-1. `applyReadonlyPragmas` closes a handle that was already opened by
+ * `openSqliteReadOnly` (`@dzhechkov/memory`) if the follow-up `busy_timeout` pragma throws.
+ * Before this helper existed, `book-kb.ts`/`agentdb-index.ts` called `db.pragma(...)`
+ * directly on the handle's `db`, outside any `try` — a pragma failure left BOTH the native
+ * connection and a tmp-copy directory (ADR-001 ladder rung 2) leaked, because `handle.cleanup()`
+ * is only wired into the `close()` this code never reaches.
+ *
+ * FR-2. `classifySqliteReadFailure` tells apart "the native module isn't installed here"
+ * (silent JSON fallback, unchanged behaviour) from "the store file itself is unreadable"
+ * (corrupt file, permission failure, …) — the second case used to be swallowed by the same
+ * bare `catch {}` in `patterns.ts`, so a corrupted `patterns.sqlite` silently looked like
+ * "fewer lessons" instead of "the store broke". `warnOnce` prints that second case exactly
+ * once per process, on stderr, without changing the JSON-fallback data path.
+ */
+
+/** Minimal shape `applyReadonlyPragmas` needs from an `openSqliteReadOnly` handle. */
+export interface PragmaTarget {
+  readonly db: { pragma: (sql: string) => void; close: () => void };
+  readonly cleanup: () => void;
+}
+
+function closeQuietly(db: { close: () => void }): void {
+  try {
+    db.close();
+  } catch {
+    // already failing on the caller's side — a close failure here must not mask the real cause
+  }
+}
+
+/**
+ * Run `fn()` and swallow any exception it throws — used for `handle.cleanup()` in the
+ * pragma-failure path (fix round 1, MEDIUM #2): a throwing `cleanup()` must not replace the
+ * original pragma error the caller is already in the middle of rethrowing.
+ */
+function cleanupQuietly(fn: () => void): void {
+  try {
+    fn();
+  } catch {
+    // the pragma failure is the error of record — a cleanup failure here must not mask it
+  }
+}
+
+/**
+ * Run `db.pragma('busy_timeout = 5000')` on an already-opened read-only handle. If the pragma
+ * throws, the connection is closed and `handle.cleanup()` is called (removing a tmp-copy
+ * directory, ADR-001 rung 2) BEFORE rethrowing — so a pragma failure never leaks either the
+ * native connection or the temporary copy. Both `close()` and `cleanup()` are individually
+ * guarded (`closeQuietly` / `cleanupQuietly`, fix round 1, MEDIUM #2) so that EITHER one throwing
+ * still lets the original pragma cause reach the caller with the db path attached, and both are
+ * still attempted exactly once each regardless of which one (if any) throws.
+ */
+export function applyReadonlyPragmas(handle: PragmaTarget, path: string): void {
+  try {
+    handle.db.pragma('busy_timeout = 5000'); // harmless on a readonly connection — kept for parity with the writer opener
+  } catch (err) {
+    closeQuietly(handle.db);
+    cleanupQuietly(() => handle.cleanup());
+    const cause = err instanceof Error ? err.message : String(err);
+    throw new Error(`failed to prepare ${path} for reading: ${cause}`);
+  }
+}
+
+/** Which of the two known catch-all reasons a store-opener failure names. */
+export type SqliteReadFailureKind = 'native-unavailable' | 'store-unreadable';
+
+/**
+ * Loader-specific signatures of "the `better-sqlite3` native module itself could not be loaded"
+ * (fix round 1, MEDIUM #1 — narrows the classifier after Codex review found the previous bare
+ * `/better-sqlite3/.test(msg)` swallowed `better-sqlite3: file is not a database`, a genuine
+ * corruption, as if the module were merely absent). Each pattern names a load-time failure mode,
+ * never a runtime/data failure that merely happens to mention the package name.
+ */
+const NATIVE_LOADER_PATTERNS: readonly RegExp[] = [
+  /Cannot find module ['"]?better-sqlite3/,
+  /better-sqlite3 is unavailable/,
+  /Could not locate the bindings file/,
+  /was compiled against a different Node\.js version/,
+  /invalid ELF header/,
+  /NODE_MODULE_VERSION/,
+];
+
+/**
+ * Classify an error caught around `SqliteBackend.openReadOnly` (or an equivalent opener):
+ * `'native-unavailable'` only when the failure is genuinely about `better-sqlite3` failing to
+ * LOAD — either `code === 'MODULE_NOT_FOUND'` with `better-sqlite3` named in the message or
+ * `requireStack` (a bare `MODULE_NOT_FOUND` for an unrelated module is NOT this — it is a
+ * different bug and must not be hidden as "native unavailable"), or the message matches one of
+ * the {@link NATIVE_LOADER_PATTERNS} native-module-loader signatures (missing module, ABI/version
+ * mismatch, corrupt/foreign binary). The existing silent JSON fallback is correct here, nothing
+ * changes. Anything else — a corrupt file (`file is not a database`), a permission failure, a
+ * genuinely unreadable store — is `'store-unreadable'`: still falls back to JSON (FR-2 does not
+ * change returned data), but the caller is expected to warn once via {@link warnOnce}.
+ */
+export function classifySqliteReadFailure(err: unknown): SqliteReadFailureKind {
+  const code = (err as { code?: string } | undefined)?.code;
+  const msg = err instanceof Error ? err.message : String(err);
+  const requireStackRaw = (err as { requireStack?: unknown } | undefined)?.requireStack;
+  const requireStack = Array.isArray(requireStackRaw) ? requireStackRaw.join('\n') : '';
+
+  if (code === 'MODULE_NOT_FOUND' && (/better-sqlite3/.test(msg) || /better-sqlite3/.test(requireStack))) {
+    return 'native-unavailable';
+  }
+  if (NATIVE_LOADER_PATTERNS.some((re) => re.test(msg))) return 'native-unavailable';
+  return 'store-unreadable';
+}
+
+const warnedKeys = new Set<string>();
+
+/**
+ * Write `text` to stderr the first time this exact `key` is seen in this process, and never
+ * again. Used to surface a `'store-unreadable'` classification exactly once per store path per
+ * process, instead of once per read call.
+ */
+export function warnOnce(key: string, text: string): void {
+  if (warnedKeys.has(key)) return;
+  warnedKeys.add(key);
+  try {
+    process.stderr.write(`${text}\n`);
+  } catch {
+    // a closed/broken stderr must not break the caller's fallback
+  }
+}

package/src/statusline.ts

@@ -70,15 +70,30 @@ export interface StatuslineData {
   readonly patterns: number;
   /** Absent on parity; missing/unreadable mirror is explicitly unavailable. */
   readonly patternMirror?:
-    | { readonly state: 'different'; readonly lexical: number; readonly vector: number }
+    | {
+      readonly state: 'in-sync' | 'different';
+      readonly lexicalMirrorable: number;
+      readonly vector: number;
+      readonly excluded: { readonly class: number; readonly noise: number };
+    }
     | { readonly state: 'unavailable' };
+  /** Vector-mirror inventory; absence is explicit instead of being encoded as a missing field. */
+  readonly mirror: {
+    readonly available: boolean;
+    readonly rows: number;
+    readonly lessons: number;
+    readonly pending: number;
+    readonly source: 'agentdb';
+  };
   /** Exact lexical-tier availability split; omitted when the enhanced readonly count cannot be established. */
   readonly patternBreakdown?: {
-    readonly source: 'lexical';
+    readonly source: 'lexical' | 'lexical+mirror';
     readonly active: number;
     readonly quarantined: number;
     /** True once quarantine contains at least one third of the lexical pool. */
     readonly attention: boolean;
+    /** Exact label drift by dzId; present only when both tiers expose readable identities. */
+    readonly tierParity?: { readonly lexicalOnly: number; readonly mirrorOnly: number };
     /** Absolute lexical/vector quarantine-label delta, present only above the tolerated drift threshold. */
     readonly tierDelta?: number;
   };
@@ -663,14 +678,38 @@ export function statuslineData(projectRoot: string, now: number = Date.now()): S
   // зеркалом не пользуется, он горел бы всегда, а вечно горящий показатель не несёт сведений.
   // Зеркало ЕСТЬ, но прочитать или разложить его не удалось: это отказ инструмента, и он горит.
   const mirrorLessons = storeRows?.vectorLessonRows;
+  const mirrorRows = storeRows?.vectorRows;
   const mirrorAbsent = storeRows !== undefined && storeRows.vectorSourcePath === undefined;
+  const lexicalMirrorable = storeRows?.lexicalMirrorableRows;
+  const excluded = {
+    class: storeRows?.lexicalExcludedClassRows ?? 0,
+    noise: storeRows?.lexicalExcludedNoiseRows ?? 0,
+  };
+  const mirrorAvailable = storeRows?.vectorSourcePath !== undefined
+    && typeof mirrorRows === 'number'
+    && mirrorLessons !== undefined;
   const patternMirror: StatuslineData['patternMirror'] = mirrorAbsent
     ? undefined
-    : storeRows === undefined || storeRows.vectorRows === 'unreadable' || mirrorLessons === undefined
+    : storeRows === undefined || storeRows.vectorRows === 'unreadable' || storeRows.vectorRows === 'busy'
+      || mirrorLessons === undefined || lexicalMirrorable === undefined
       ? { state: 'unavailable' }
-      : mirrorLessons !== patterns
-        ? { state: 'different', lexical: patterns, vector: mirrorLessons }
-        : undefined;
+      : {
+        state: mirrorLessons !== lexicalMirrorable ? 'different' : 'in-sync',
+        lexicalMirrorable,
+        vector: mirrorLessons,
+        excluded,
+      };
+  const mirror: StatuslineData['mirror'] = {
+    available: mirrorAvailable,
+    rows: typeof mirrorRows === 'number' ? mirrorRows : 0,
+    lessons: mirrorAvailable ? mirrorLessons : 0,
+    pending: mirrorAbsent && lexicalMirrorable !== undefined
+      ? lexicalMirrorable
+      : mirrorAvailable && lexicalMirrorable !== undefined
+        ? Math.max(0, lexicalMirrorable - mirrorLessons)
+        : 0,
+    source: 'agentdb',
+  };
 
   let patternBreakdown: StatuslineData['patternBreakdown'];
   try {
@@ -678,14 +717,22 @@ export function statuslineData(projectRoot: string, now: number = Date.now()): S
       && typeof storeRows.lexicalRows === 'number'
       && typeof storeRows.lexicalQuarantinedRows === 'number') {
       const quarantined = storeRows.lexicalQuarantinedRows;
-      const tierDelta = typeof storeRows.vectorQuarantinedRows === 'number'
-        ? Math.abs(quarantined - storeRows.vectorQuarantinedRows)
+      const tierDelta = mirrorAvailable
+        && typeof storeRows.lexicalMirrorableQuarantinedRows === 'number'
+        && typeof storeRows.vectorQuarantinedRows === 'number'
+        ? Math.abs(storeRows.lexicalMirrorableQuarantinedRows - storeRows.vectorQuarantinedRows)
         : undefined;
       patternBreakdown = {
-        source: 'lexical',
+        source: mirrorAvailable ? 'lexical+mirror' : 'lexical',
         active: storeRows.lexicalRows - quarantined,
         quarantined,
         attention: quarantined > 0 && quarantined * 3 >= storeRows.lexicalRows,
+        ...(storeRows.quarantineTierParity === undefined ? {} : {
+          tierParity: {
+            lexicalOnly: storeRows.quarantineTierParity.lexicalOnly,
+            mirrorOnly: storeRows.quarantineTierParity.mirrorOnly,
+          },
+        }),
         ...(tierDelta !== undefined && tierDelta > QUARANTINE_TIER_DRIFT_TOLERANCE ? { tierDelta } : {}),
       };
     }
@@ -723,6 +770,7 @@ export function statuslineData(projectRoot: string, now: number = Date.now()): S
 
   return {
     patterns,
+    mirror,
     ...(patternMirror !== undefined ? { patternMirror } : {}),
     ...(patternBreakdown !== undefined ? { patternBreakdown } : {}),
     ...(usedPatterns !== undefined ? { usedPatterns } : {}),

package/src/store-counts.ts

@@ -2,10 +2,16 @@
 import { createRequire } from 'node:module';
 import { existsSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import type { MemoryRecord } from '@dzhechkov/memory';
+import { patternRecordId, recordToPattern } from './patterns.js';
+import { isMirrorableRecord } from './vector-tier.js';
 
 interface ReadonlyCountDb {
   pragma: (s: string) => void;
-  prepare: (q: string) => { get: (...a: unknown[]) => unknown };
+  prepare: (q: string) => {
+    get: (...a: unknown[]) => unknown;
+    all: (...a: unknown[]) => unknown[];
+  };
   close: () => void;
 }
 
@@ -16,6 +22,91 @@ export interface StoreCountOptions {
   readonly attempts?: number;
 }
 
+export interface QuarantineTierRow {
+  readonly id?: string;
+  readonly dzId?: string;
+  /** Content-addressed alias used by the teach-time mirror before a lexical row is re-keyed. */
+  readonly patternRecordId?: string;
+  readonly quarantined?: boolean;
+  readonly qStatus?: unknown;
+  readonly metadata?: Record<string, unknown> | string | null;
+}
+
+export interface QuarantineTierParity {
+  readonly both: number;
+  readonly lexicalOnly: number;
+  readonly mirrorOnly: number;
+  readonly ids: {
+    readonly both: readonly string[];
+    readonly lexicalOnly: readonly string[];
+    readonly mirrorOnly: readonly string[];
+  };
+}
+
+function rowMetadata(row: QuarantineTierRow): Record<string, unknown> {
+  if (typeof row.metadata === 'object' && row.metadata !== null) return row.metadata;
+  if (typeof row.metadata !== 'string') return {};
+  try {
+    const parsed = JSON.parse(row.metadata) as unknown;
+    return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+interface QuarantineIdentity {
+  readonly primary: string;
+  readonly aliases: ReadonlySet<string>;
+}
+
+function quarantineIdentities(rows: readonly QuarantineTierRow[]): QuarantineIdentity[] {
+  const identities = new Map<string, QuarantineIdentity>();
+  for (const row of rows) {
+    const metadata = rowMetadata(row);
+    const quarantined = row.quarantined === true
+      || row.qStatus === 'quarantined'
+      || metadata['qStatus'] === 'quarantined';
+    if (!quarantined) continue;
+    const candidates = [row.dzId, metadata['dzId'], row.id, row.patternRecordId]
+      .filter((id): id is string => typeof id === 'string' && id !== '');
+    const primary = candidates[0];
+    if (primary === undefined) continue;
+    identities.set(primary, { primary, aliases: new Set(candidates) });
+  }
+  return [...identities.values()];
+}
+
+/** Pure dual-key comparison for active quarantine labels in the lexical and mirror tiers. */
+export function quarantineTierParity(
+  lexicalRows: readonly QuarantineTierRow[],
+  mirrorRows: readonly QuarantineTierRow[],
+): QuarantineTierParity {
+  const lexical = quarantineIdentities(lexicalRows);
+  const mirror = quarantineIdentities(mirrorRows);
+  const lexicalKeys = new Set(lexical.flatMap((identity) => [...identity.aliases]));
+  const mirrorKeys = new Set(mirror.flatMap((identity) => [...identity.aliases]));
+  const both = [...new Set(lexical.flatMap((identity) => {
+    const matched = [...identity.aliases].find((id) => mirrorKeys.has(id));
+    return matched === undefined ? [] : [matched];
+  }))].sort();
+  const lexicalOnly = lexical
+    .filter((identity) => ![...identity.aliases].some((id) => mirrorKeys.has(id)))
+    .map((identity) => identity.primary)
+    .sort();
+  const mirrorOnly = mirror
+    .filter((identity) => ![...identity.aliases].some((id) => lexicalKeys.has(id)))
+    .map((identity) => identity.primary)
+    .sort();
+  return {
+    both: both.length,
+    lexicalOnly: lexicalOnly.length,
+    mirrorOnly: mirrorOnly.length,
+    ids: { both, lexicalOnly, mirrorOnly },
+  };
+}
+
 type DatabaseRequire = (id: string) => unknown;
 
 function isBusy(error: unknown): boolean {
@@ -45,6 +136,13 @@ function normalizedOptions(options: StoreCountOptions): { busyTimeoutMs: number;
 
 export interface LearningStoreRowCounts {
   readonly lexicalRows: StoreRowCount;
+  /** Lexical rows accepted by the same class/noise gate as the vector mirror writer. */
+  readonly lexicalMirrorableRows?: number;
+  /** Mirrorable lexical rows whose current qStatus is quarantined. */
+  readonly lexicalMirrorableQuarantinedRows?: number;
+  /** Mutually exclusive exclusion buckets; class takes precedence over noise. */
+  readonly lexicalExcludedClassRows?: number;
+  readonly lexicalExcludedNoiseRows?: number;
   /** Exact active quarantine labels in the selected lexical SQLite tier; absent for fallback/error paths. */
   readonly lexicalQuarantinedRows?: number;
   /** Physical lexical population counted; jsonl and SQLite maxima are not comparable. */
@@ -71,6 +169,8 @@ export interface LearningStoreRowCounts {
   readonly vectorQuarantinedRows?: number;
   /** Present when the vector store file exists, including when its count is unreadable. */
   readonly vectorSourcePath?: string;
+  /** Exact qStatus parity by dzId; absent when either tier cannot establish quarantine ids. */
+  readonly quarantineTierParity?: QuarantineTierParity;
 }
 
 function countJsonlRowsReadonly(path: string): number | 'unreadable' {
@@ -133,8 +233,132 @@ export function countSqliteRowsReadonly(
 interface SqliteRowsWithQuarantine {
   readonly rows: number;
   readonly quarantinedRows?: number;
+  readonly mirrorableRows?: number;
+  readonly mirrorableQuarantinedRows?: number;
+  readonly excludedClassRows?: number;
+  readonly excludedNoiseRows?: number;
   /** Только для зеркала: подсчёт уроков внутри общего объёма. */
   readonly lessonRows?: number;
+  readonly quarantinedIdentities?: readonly QuarantineTierRow[];
+}
+
+function lexicalMirrorPopulation(db: ReadonlyCountDb): Pick<
+  SqliteRowsWithQuarantine,
+  'mirrorableRows' | 'mirrorableQuarantinedRows' | 'excludedClassRows' | 'excludedNoiseRows' | 'quarantinedIdentities'
+> | undefined {
+  let rows: unknown[];
+  let idsEstablished = true;
+  try {
+    rows = db.prepare('SELECT id, skill_id, text, score, outcome, timestamp, metadata FROM memory_records').all();
+  } catch {
+    try {
+      rows = db.prepare('SELECT id, text, metadata FROM memory_records').all();
+    } catch {
+      idsEstablished = false;
+      try {
+        rows = db.prepare('SELECT text, metadata FROM memory_records').all();
+      } catch {
+        try {
+          // Legacy/minimal schemas can still establish the class exclusion. With no text column there
+          // is no observable noise payload, so every non-class row stays in the comparable population.
+          rows = db.prepare("SELECT '' AS text, metadata FROM memory_records").all();
+        } catch {
+          return undefined;
+        }
+      }
+    }
+  }
+
+  let mirrorableRows = 0;
+  let mirrorableQuarantinedRows = 0;
+  let excludedClassRows = 0;
+  let excludedNoiseRows = 0;
+  const quarantinedRows: QuarantineTierRow[] = [];
+  for (const value of rows) {
+    const row = value as {
+      id?: unknown;
+      skill_id?: unknown;
+      text?: unknown;
+      score?: unknown;
+      outcome?: unknown;
+      timestamp?: unknown;
+      metadata?: unknown;
+    };
+    let metadata: Record<string, unknown> = {};
+    if (typeof row.metadata === 'string') {
+      try {
+        const parsed = JSON.parse(row.metadata) as unknown;
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+          metadata = parsed as Record<string, unknown>;
+        }
+      } catch { /* malformed metadata carries no class/quarantine claim */ }
+    }
+    const text = typeof row.text === 'string' ? row.text : '';
+    const lessonForm = metadata['lessonForm'] === 'class' ? 'class' as const : undefined;
+    const record = { pattern: text, ...(lessonForm === undefined ? {} : { lessonForm }) };
+    if (!isMirrorableRecord(record)) {
+      if (lessonForm === 'class') excludedClassRows += 1;
+      else excludedNoiseRows += 1;
+      continue;
+    }
+    mirrorableRows += 1;
+    if (metadata['qStatus'] === 'quarantined') {
+      mirrorableQuarantinedRows += 1;
+      if (typeof row.id !== 'string' || row.id === '') {
+        idsEstablished = false;
+        continue;
+      }
+      let derivedId: string | undefined;
+      if (typeof row.text === 'string'
+        && typeof row.score === 'number'
+        && typeof row.outcome === 'string'
+        && typeof row.timestamp === 'string') {
+        const stringMetadata = Object.fromEntries(
+          Object.entries(metadata).filter((entry): entry is [string, string] => typeof entry[1] === 'string'),
+        );
+        const record: MemoryRecord = {
+          id: row.id,
+          skillId: typeof row.skill_id === 'string' ? row.skill_id : '',
+          text: row.text,
+          score: row.score,
+          outcome: row.outcome,
+          timestamp: row.timestamp,
+          metadata: stringMetadata,
+        };
+        derivedId = patternRecordId(recordToPattern(record));
+      }
+      quarantinedRows.push({
+        id: row.id,
+        ...(derivedId === undefined ? {} : { patternRecordId: derivedId }),
+        qStatus: 'quarantined',
+      });
+    }
+  }
+  return {
+    mirrorableRows,
+    mirrorableQuarantinedRows,
+    excludedClassRows,
+    excludedNoiseRows,
+    ...(idsEstablished ? { quarantinedIdentities: quarantinedRows } : {}),
+  };
+}
+
+function vectorQuarantinedIds(db: ReadonlyCountDb): readonly QuarantineTierRow[] | undefined {
+  try {
+    const rows = db.prepare(`SELECT metadata FROM reasoning_patterns
+      WHERE task_type IN ('dz-teach', 'dz-learning')
+        AND json_valid(metadata)
+        AND json_extract(metadata, '$.qStatus') = 'quarantined'`).all() as Array<{ metadata?: unknown }>;
+    const rowsWithIds: QuarantineTierRow[] = [];
+    for (const row of rows) {
+      const metadata = rowMetadata({ metadata: typeof row.metadata === 'string' ? row.metadata : null });
+      if (typeof metadata['dzId'] !== 'string' || metadata['dzId'] === '') return undefined;
+      rowsWithIds.push({ dzId: metadata['dzId'], qStatus: 'quarantined' });
+    }
+    return rowsWithIds;
+  } catch {
+    return undefined;
+  }
 }
 
 /** One aggregate query on the healthy path; an unsupported metadata shape falls back to total-only. */
@@ -168,9 +392,13 @@ function countSqliteRowsWithQuarantineReadonly(
             FROM reasoning_patterns`;
           const row = db.prepare(sql).get() as { cnt?: unknown; quarantined?: unknown; lessons?: unknown };
           if (typeof row?.cnt !== 'number' || typeof row.quarantined !== 'number') return 'unreadable';
+          const lexical = table === 'memory_records' ? lexicalMirrorPopulation(db) : undefined;
+          const quarantinedRows = table === 'reasoning_patterns' ? vectorQuarantinedIds(db) : undefined;
           return {
             rows: row.cnt,
             quarantinedRows: row.quarantined,
+            ...(lexical ?? {}),
+            ...(quarantinedRows === undefined ? {} : { quarantinedIdentities: quarantinedRows }),
             ...(typeof row.lessons === 'number' ? { lessonRows: row.lessons } : {}),
           };
         } catch (error) {
@@ -247,8 +475,23 @@ export function countLearningStoreRowsReadonly(
   const ignoredJsonl = lexicalSource === 'sqlite' && existsSync(jsonlPath)
     ? countJsonlRowsReadonly(jsonlPath)
     : undefined;
+  const quarantineParity = typeof lexicalSqlite === 'object'
+    && lexicalSqlite.quarantinedIdentities !== undefined
+    && typeof vectorSqlite === 'object'
+    && vectorSqlite.quarantinedIdentities !== undefined
+    ? quarantineTierParity(
+      lexicalSqlite.quarantinedIdentities,
+      vectorSqlite.quarantinedIdentities,
+    )
+    : undefined;
   return {
     lexicalRows,
+    ...(typeof lexicalSqlite !== 'object' || lexicalSqlite.mirrorableRows === undefined ? {} : {
+      lexicalMirrorableRows: lexicalSqlite.mirrorableRows,
+      lexicalMirrorableQuarantinedRows: lexicalSqlite.mirrorableQuarantinedRows ?? 0,
+      lexicalExcludedClassRows: lexicalSqlite.excludedClassRows ?? 0,
+      lexicalExcludedNoiseRows: lexicalSqlite.excludedNoiseRows ?? 0,
+    }),
     ...(typeof lexicalSqlite !== 'object' || lexicalSqlite.quarantinedRows === undefined ? {} : {
       lexicalQuarantinedRows: lexicalSqlite.quarantinedRows,
     }),
@@ -267,5 +510,6 @@ export function countLearningStoreRowsReadonly(
       vectorQuarantinedRows: vectorSqlite.quarantinedRows,
     }),
     ...(vectorExists ? { vectorSourcePath: vectorPath } : {}),
+    ...(quarantineParity === undefined ? {} : { quarantineTierParity: quarantineParity }),
   };
 }