@dzhechkov/harness-core 0.8.28 → 0.8.30

package/src/store-counts.ts

@@ -9,8 +9,42 @@ interface ReadonlyCountDb {
   close: () => void;
 }
 
+export type StoreRowCount = number | 'unreadable' | 'busy';
+
+export interface StoreCountOptions {
+  readonly busyTimeoutMs?: number;
+  readonly attempts?: number;
+}
+
+type DatabaseRequire = (id: string) => unknown;
+
+function isBusy(error: unknown): boolean {
+  return typeof error === 'object' && error !== null
+    && (error as { code?: unknown }).code === 'SQLITE_BUSY';
+}
+
+function isInitializing(error: unknown): boolean {
+  return typeof error === 'object' && error !== null
+    && (error as { code?: unknown }).code === 'SQLITE_ERROR'
+    && typeof (error as { message?: unknown }).message === 'string'
+    && (error as { message: string }).message.includes('no such table');
+}
+
+const INITIALIZATION_RETRY_WAIT = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+
+function waitForInitializationRetry(busyTimeoutMs: number): void {
+  Atomics.wait(INITIALIZATION_RETRY_WAIT, 0, 0, busyTimeoutMs);
+}
+
+function normalizedOptions(options: StoreCountOptions): { busyTimeoutMs: number; attempts: number } {
+  return {
+    busyTimeoutMs: options.busyTimeoutMs ?? 100,
+    attempts: options.attempts ?? 1,
+  };
+}
+
 export interface LearningStoreRowCounts {
-  readonly lexicalRows: number | 'unreadable';
+  readonly lexicalRows: StoreRowCount;
   /** 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. */
@@ -26,7 +60,7 @@ export interface LearningStoreRowCounts {
    * до уроков уронило бы наблюдение с 1774 до 631 — страж прочитал бы это как обвал стора.
    * Для показателя зеркала в панели есть отдельное поле `vectorLessonRows`.
    */
-  readonly vectorRows: number | 'unreadable';
+  readonly vectorRows: StoreRowCount;
   /**
    * Только зеркальные УРОКИ (task_type dz-teach/dz-learning) — величина, сравнимая с `lexicalRows`.
    * Отсутствует, когда зеркала нет или разложить его по родам не удалось: тогда показатель обязан
@@ -52,21 +86,48 @@ function countJsonlRowsReadonly(path: string): number | 'unreadable' {
 export function countSqliteRowsReadonly(
   sqlitePath: string,
   table: 'memory_records' | 'reasoning_patterns',
-): number | undefined {
-  try {
-    const require = createRequire(import.meta.url);
-    const Database = require('better-sqlite3') as new (p: string, o?: object) => ReadonlyCountDb;
-    const db = new Database(sqlitePath, { readonly: true });
+): number | undefined;
+export function countSqliteRowsReadonly(
+  sqlitePath: string,
+  table: 'memory_records' | 'reasoning_patterns',
+  options: StoreCountOptions,
+  requireModule?: DatabaseRequire,
+): StoreRowCount;
+export function countSqliteRowsReadonly(
+  sqlitePath: string,
+  table: 'memory_records' | 'reasoning_patterns',
+  options?: StoreCountOptions,
+  requireModule: DatabaseRequire = createRequire(import.meta.url),
+): number | undefined | StoreRowCount {
+  const legacyUndefined = options === undefined;
+  const { busyTimeoutMs, attempts } = normalizedOptions(options ?? {});
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
     try {
-      db.pragma('busy_timeout = 100');
-      const row = db.prepare(`SELECT COUNT(*) as cnt FROM ${table}`).get() as { cnt?: unknown };
-      return typeof row?.cnt === 'number' ? row.cnt : undefined;
-    } finally {
-      db.close();
+      const Database = requireModule('better-sqlite3') as new (p: string, o?: object) => ReadonlyCountDb;
+      const db = new Database(sqlitePath, { readonly: true });
+      try {
+        db.pragma(`busy_timeout = ${busyTimeoutMs}`);
+        const row = db.prepare(`SELECT COUNT(*) as cnt FROM ${table}`).get() as { cnt?: unknown };
+        return typeof row?.cnt === 'number' ? row.cnt : (legacyUndefined ? undefined : 'unreadable');
+      } finally {
+        db.close();
+      }
+    } catch (error) {
+      if (isBusy(error)) {
+        if (attempt + 1 < attempts) continue;
+        return legacyUndefined ? undefined : 'busy';
+      }
+      if (isInitializing(error)) {
+        if (attempt + 1 < attempts) {
+          waitForInitializationRetry(busyTimeoutMs);
+          continue;
+        }
+        return legacyUndefined ? undefined : 'unreadable';
+      }
+      return legacyUndefined ? undefined : 'unreadable';
     }
-  } catch {
-    return undefined;
   }
+  return legacyUndefined ? undefined : 'busy';
 }
 
 interface SqliteRowsWithQuarantine {
@@ -80,61 +141,79 @@ interface SqliteRowsWithQuarantine {
 function countSqliteRowsWithQuarantineReadonly(
   sqlitePath: string,
   table: 'memory_records' | 'reasoning_patterns',
-): SqliteRowsWithQuarantine | undefined {
-  try {
-    const require = createRequire(import.meta.url);
-    const Database = require('better-sqlite3') as new (p: string, o?: object) => ReadonlyCountDb;
-    const db = new Database(sqlitePath, { readonly: true });
+  options: StoreCountOptions,
+  requireModule: DatabaseRequire,
+): SqliteRowsWithQuarantine | 'unreadable' | 'busy' {
+  const { busyTimeoutMs, attempts } = normalizedOptions(options);
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
     try {
-      db.pragma('busy_timeout = 100');
+      const Database = requireModule('better-sqlite3') as new (p: string, o?: object) => ReadonlyCountDb;
+      const db = new Database(sqlitePath, { readonly: true });
       try {
-        const sql = table === 'memory_records'
-          ? `SELECT COALESCE(SUM(n), 0) AS cnt,
+        db.pragma(`busy_timeout = ${busyTimeoutMs}`);
+        try {
+          const sql = table === 'memory_records'
+            ? `SELECT COALESCE(SUM(n), 0) AS cnt,
               COALESCE(SUM(CASE WHEN q_status = 'quarantined' THEN n ELSE 0 END), 0) AS quarantined
             FROM (
               SELECT CASE WHEN json_valid(metadata) THEN json_extract(metadata, '$.qStatus') END AS q_status,
                 COUNT(*) AS n
               FROM memory_records GROUP BY 1
             )`
-          : `SELECT COUNT(*) AS cnt,
+            : `SELECT COUNT(*) AS cnt,
               COALESCE(SUM(CASE WHEN task_type IN ('dz-teach', 'dz-learning') THEN 1 ELSE 0 END), 0) AS lessons,
               COALESCE(SUM(CASE WHEN task_type IN ('dz-teach', 'dz-learning')
                 AND json_valid(metadata)
                 AND json_extract(metadata, '$.qStatus') = 'quarantined' THEN 1 ELSE 0 END), 0) AS quarantined
             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 undefined;
-        return {
-          rows: row.cnt,
-          quarantinedRows: row.quarantined,
-          ...(typeof row.lessons === 'number' ? { lessonRows: row.lessons } : {}),
-        };
-      } catch {
-        // Запасной путь: общий объём берём всегда, а разложение по родам пробуем ОТДЕЛЬНО —
-        // схема без `metadata`, но с `task_type` уроки различает, и терять это не за что.
-        // Если не различает и её — lessonRows остаётся неизвестным, и показатель обязан сказать
-        // «не читается» вместо мнимого совпадения.
-        const row = db.prepare(`SELECT COUNT(*) AS cnt FROM ${table}`).get() as { cnt?: unknown };
-        if (typeof row?.cnt !== 'number') return undefined;
-        if (table !== 'reasoning_patterns') return { rows: row.cnt };
-        try {
-          const lesson = db.prepare(
-            `SELECT COUNT(*) AS cnt 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';
+          return {
+            rows: row.cnt,
+            quarantinedRows: row.quarantined,
+            ...(typeof row.lessons === 'number' ? { lessonRows: row.lessons } : {}),
+          };
+        } catch (error) {
+          if (isBusy(error) || isInitializing(error)) throw error;
+          // Запасной путь: общий объём берём всегда, а разложение по родам пробуем ОТДЕЛЬНО —
+          // схема без `metadata`, но с `task_type` уроки различает, и терять это не за что.
+          // Если не различает и её — lessonRows остаётся неизвестным, и показатель обязан сказать
+          // «не читается» вместо мнимого совпадения.
+          const row = db.prepare(`SELECT COUNT(*) AS cnt FROM ${table}`).get() as { cnt?: unknown };
+          if (typeof row?.cnt !== 'number') return 'unreadable';
+          if (table !== 'reasoning_patterns') return { rows: row.cnt };
+          try {
+            const lesson = db.prepare(
+              `SELECT COUNT(*) AS cnt FROM reasoning_patterns
               WHERE task_type IN ('dz-teach', 'dz-learning')`,
-          ).get() as { cnt?: unknown };
-          return typeof lesson?.cnt === 'number'
-            ? { rows: row.cnt, lessonRows: lesson.cnt }
-            : { rows: row.cnt };
-        } catch {
-          return { rows: row.cnt };
+            ).get() as { cnt?: unknown };
+            return typeof lesson?.cnt === 'number'
+              ? { rows: row.cnt, lessonRows: lesson.cnt }
+              : { rows: row.cnt };
+          } catch (lessonError) {
+            if (isBusy(lessonError) || isInitializing(lessonError)) throw lessonError;
+            return { rows: row.cnt };
+          }
         }
+      } finally {
+        db.close();
       }
-    } finally {
-      db.close();
+    } catch (error) {
+      if (isBusy(error)) {
+        if (attempt + 1 < attempts) continue;
+        return 'busy';
+      }
+      if (isInitializing(error)) {
+        if (attempt + 1 < attempts) {
+          waitForInitializationRetry(busyTimeoutMs);
+          continue;
+        }
+        return 'unreadable';
+      }
+      return 'unreadable';
     }
-  } catch {
-    return undefined;
   }
+  return 'busy';
 }
 
 /**
@@ -142,7 +221,11 @@ function countSqliteRowsWithQuarantineReadonly(
  * Missing tiers count as zero; an existing tier that cannot be counted is
  * explicitly `unreadable`.
  */
-export function countLearningStoreRowsReadonly(projectRoot: string): LearningStoreRowCounts {
+export function countLearningStoreRowsReadonly(
+  projectRoot: string,
+  options: StoreCountOptions = {},
+  requireModule: DatabaseRequire = createRequire(import.meta.url),
+): LearningStoreRowCounts {
   const root = resolve(projectRoot);
   const lexicalPath = join(root, '.dz', 'memory', 'patterns.sqlite');
   const jsonlPath = join(root, '.dz', 'patterns.jsonl');
@@ -150,23 +233,23 @@ export function countLearningStoreRowsReadonly(projectRoot: string): LearningSto
   const vectorExists = existsSync(vectorPath);
   const lexicalSource = existsSync(lexicalPath) ? 'sqlite' : 'jsonl';
   const lexicalSqlite = lexicalSource === 'sqlite'
-    ? countSqliteRowsWithQuarantineReadonly(lexicalPath, 'memory_records')
+    ? countSqliteRowsWithQuarantineReadonly(lexicalPath, 'memory_records', options, requireModule)
     : undefined;
-  let lexicalRows: number | 'unreadable';
+  let lexicalRows: StoreRowCount;
   if (lexicalSource === 'sqlite') {
-    lexicalRows = lexicalSqlite?.rows ?? 'unreadable';
+    lexicalRows = typeof lexicalSqlite === 'object' ? lexicalSqlite.rows : lexicalSqlite ?? 'unreadable';
   } else {
     lexicalRows = countJsonlRowsReadonly(jsonlPath);
   }
   const vectorSqlite = vectorExists
-    ? countSqliteRowsWithQuarantineReadonly(vectorPath, 'reasoning_patterns')
+    ? countSqliteRowsWithQuarantineReadonly(vectorPath, 'reasoning_patterns', options, requireModule)
     : undefined;
   const ignoredJsonl = lexicalSource === 'sqlite' && existsSync(jsonlPath)
     ? countJsonlRowsReadonly(jsonlPath)
     : undefined;
   return {
     lexicalRows,
-    ...(lexicalSqlite?.quarantinedRows === undefined ? {} : {
+    ...(typeof lexicalSqlite !== 'object' || lexicalSqlite.quarantinedRows === undefined ? {} : {
       lexicalQuarantinedRows: lexicalSqlite.quarantinedRows,
     }),
     lexicalSource,
@@ -175,9 +258,12 @@ export function countLearningStoreRowsReadonly(projectRoot: string): LearningSto
       lexicalIgnoredRows: ignoredJsonl,
       lexicalIgnoredSourcePath: jsonlPath,
     }),
-    vectorRows: vectorExists ? (vectorSqlite?.rows ?? 'unreadable') : 0,
-    ...(vectorSqlite?.lessonRows === undefined ? {} : { vectorLessonRows: vectorSqlite.lessonRows }),
-    ...(vectorSqlite?.quarantinedRows === undefined ? {} : {
+    vectorRows: vectorExists
+      ? (typeof vectorSqlite === 'object' ? vectorSqlite.rows : vectorSqlite ?? 'unreadable')
+      : 0,
+    ...(typeof vectorSqlite !== 'object' || vectorSqlite.lessonRows === undefined
+      ? {} : { vectorLessonRows: vectorSqlite.lessonRows }),
+    ...(typeof vectorSqlite !== 'object' || vectorSqlite.quarantinedRows === undefined ? {} : {
       vectorQuarantinedRows: vectorSqlite.quarantinedRows,
     }),
     ...(vectorExists ? { vectorSourcePath: vectorPath } : {}),

package/src/store-guard.ts

@@ -92,9 +92,9 @@ export interface StoreMarkWriteOptions {
   readonly expectedPreviousLexicalSource?: StoreCountSource | 'unknown';
 }
 
-export type StoreRowCount = number | 'unreadable';
+export type StoreRowCount = number | 'unreadable' | 'busy';
 
-export type StoreHealthVerdict = 'ok' | 'collapsed' | 'cold-start-over-existing' | 'source-changed' | 'unreadable' | 'no-mark';
+export type StoreHealthVerdict = 'ok' | 'collapsed' | 'cold-start-over-existing' | 'source-changed' | 'unreadable' | 'busy' | 'no-mark';
 
 export interface StoreHealth {
   readonly verdict: StoreHealthVerdict;
@@ -354,6 +354,12 @@ export function checkStoreHealth(input: StoreHealthInput): StoreHealth {
       reason: `${unreadable.join(' and ')} store${unreadable.length > 1 ? 's are' : ' is'} unreadable`,
     };
   }
+  if (lexicalRows === 'busy' || vectorRows === 'busy') {
+    return {
+      verdict: 'busy',
+      reason: 'lexical store busy — another writer holds it; health not measured this run',
+    };
+  }
   if (mark === undefined) return { verdict: 'no-mark', reason: 'no store mark exists for this project' };
 
   const lexicalCount = lexicalRows as number;