nlm-memory 0.4.2 → 0.5.1

package/src/core/recall-facts/fact-recall-service.ts

@@ -1,327 +0,0 @@
-/**
- * FactRecallService — agent-facing recall over the FactStore.
- *
- * Mirrors RecallService's keyword / semantic / hybrid pattern but works on
- * Fact records, not Session records. Sessions and facts answer different
- * questions and have incompatibly-shaped results, so this is a separate
- * service with its own MCP tool — see Section 4 of factstore-design.md.
- *
- * Filter pipeline:
- *   1. Storage pre-filter (subject, predicate, kind, minConfidence,
- *      includeSuperseded). Cheap SQL.
- *   2. Keyword scoring over (value, subject, predicate). Pure, in-memory.
- *   3. Semantic KNN via fact_embeddings vec0 (when mode != keyword).
- *   4. Hybrid merge: 0.6 semantic + 0.4 keyword, matching the session
- *      recall weights.
- *
- * Confidence policy: default `minConfidence` is 0.6 (Section 1 of the plan).
- * Facts with classifier confidence in [0.4, 0.6) get written by
- * extractFacts but stay out of agent recall unless the caller lowers the
- * floor explicitly.
- */
-
-import type { FactStore } from "@ports/fact-store.js";
-import type { LLMClient } from "@ports/llm-client.js";
-import { LLMUnreachableError } from "@ports/llm-client.js";
-import type {
-  Fact,
-  FactHit,
-  FactMatchField,
-  FactRecallQuery,
-  FactRecallResult,
-  RecallMode,
-} from "@shared/types.js";
-import { tokenSet } from "@core/recall/tokenize.js";
-
-const DEFAULT_LIMIT = 10;
-const MAX_LIMIT = 100;
-const DEFAULT_MIN_CONFIDENCE = 0.6;
-const STORAGE_FETCH_CAP = 500;
-const HYBRID_KW_WEIGHT = 0.4;
-const HYBRID_SEM_WEIGHT = 0.6;
-const SEMANTIC_OVERFETCH = 3;
-
-const FIELD_WEIGHTS = {
-  value: 3,
-  subject: 1,
-  predicate: 1,
-} as const;
-
-export interface FactRecallServiceDeps {
-  readonly factStore: FactStore;
-  readonly llm: LLMClient;
-}
-
-export class FactRecallService {
-  constructor(private readonly deps: FactRecallServiceDeps) {}
-
-  async search(input: FactRecallQuery): Promise<FactRecallResult> {
-    const mode: RecallMode = input.mode ?? "keyword";
-    const limit = clampLimit(input.limit);
-    const subject = input.subject ?? null;
-    const predicate = input.predicate ?? null;
-    const kind = input.kind ?? null;
-    const queryText = (input.query ?? "").trim();
-
-    const empty: FactRecallResult = {
-      query: queryText,
-      subject,
-      predicate,
-      kind,
-      mode,
-      limit,
-      total: 0,
-      results: [],
-    };
-
-    // A query with no signal at all → empty. Either free-text query, or a
-    // structured filter (subject / predicate / kind) must be provided.
-    if (!queryText && subject === null && predicate === null && kind === null) {
-      return empty;
-    }
-
-    const filter: Parameters<FactStore["listForRecall"]>[0] = {
-      includeSuperseded: input.includeSuperseded === true,
-      minConfidence: input.minConfidence ?? DEFAULT_MIN_CONFIDENCE,
-      limit: STORAGE_FETCH_CAP,
-      ...(input.subject !== undefined ? { subject: input.subject } : {}),
-      ...(input.predicate !== undefined ? { predicate: input.predicate } : {}),
-      ...(input.kind !== undefined ? { kind: input.kind } : {}),
-    };
-
-    const candidates = await this.deps.factStore.listForRecall(filter);
-    if (candidates.length === 0) return empty;
-
-    const byId = new Map<string, Fact>(candidates.map((f) => [f.id, f]));
-    const queryTokens = queryText ? new Set(tokenSet(queryText)) : new Set<string>();
-
-    const kwHits =
-      mode === "keyword" || mode === "hybrid"
-        ? scoreAll(candidates, queryTokens)
-        : [];
-
-    let semHits: ReadonlyArray<SemanticHit> = [];
-    let semError: "ollama_unreachable" | null = null;
-    if ((mode === "semantic" || mode === "hybrid") && queryText) {
-      try {
-        semHits = await this.runSemantic(queryText, byId, limit * SEMANTIC_OVERFETCH);
-      } catch (err) {
-        if (err instanceof LLMUnreachableError) {
-          semError = "ollama_unreachable";
-        } else {
-          throw err;
-        }
-      }
-    }
-
-    if (mode === "semantic" && semError) {
-      return { ...empty, modeUnavailable: semError };
-    }
-
-    // For pure structured queries (no query text, just subject/predicate),
-    // a keyword pass with empty tokens scores zero and a semantic pass has
-    // nothing to embed. Fall back to returning the storage filter result
-    // ordered by created_at DESC. Applies to keyword AND hybrid — hybrid
-    // is the MCP default, so this path catches exact subject+predicate
-    // lookups from agent callers that pass no query text.
-    if ((mode === "keyword" || mode === "hybrid") && !queryText) {
-      const rows = candidates
-        .slice(0, limit)
-        .map((f) => factToHit(f, 0, []));
-      return finalize(queryText, subject, predicate, kind, mode, limit, rows);
-    }
-
-    if (mode === "keyword") {
-      return finalize(queryText, subject, predicate, kind, mode, limit, kwHits.map(toKeywordHit));
-    }
-
-    if (mode === "semantic") {
-      return finalize(queryText, subject, predicate, kind, mode, limit, semHits.map(toSemanticHit));
-    }
-
-    // hybrid
-    const merged = mergeHybrid(kwHits, semHits, byId);
-    const result = finalize(queryText, subject, predicate, kind, mode, limit, merged);
-    return semError ? { ...result, modeUnavailable: semError } : result;
-  }
-
-  private async runSemantic(
-    query: string,
-    byId: ReadonlyMap<string, Fact>,
-    fetchLimit: number,
-  ): Promise<ReadonlyArray<SemanticHit>> {
-    const embedding = await this.deps.llm.embed(query, "query");
-    const neighbors = await this.deps.factStore.semanticSearch(embedding.vector, fetchLimit);
-    const hits: SemanticHit[] = [];
-    for (const n of neighbors) {
-      const fact = byId.get(n.factId);
-      if (!fact) continue; // candidate was filtered out by subject/predicate/conf
-      hits.push({ fact, similarity: cosineFromL2(n.distance) });
-    }
-    return hits;
-  }
-}
-
-interface KeywordHit {
-  readonly fact: Fact;
-  readonly score: number;
-  readonly matchedIn: ReadonlyArray<FactMatchField>;
-}
-
-interface SemanticHit {
-  readonly fact: Fact;
-  readonly similarity: number;
-}
-
-function scoreAll(
-  facts: ReadonlyArray<Fact>,
-  queryTokens: ReadonlySet<string>,
-): ReadonlyArray<KeywordHit> {
-  if (queryTokens.size === 0) return [];
-  const hits: KeywordHit[] = [];
-  for (const f of facts) {
-    const { score, matchedIn } = scoreFact(f, queryTokens);
-    if (score > 0) hits.push({ fact: f, score, matchedIn });
-  }
-  hits.sort((a, b) => b.score - a.score);
-  return hits;
-}
-
-function scoreFact(
-  fact: Fact,
-  queryTokens: ReadonlySet<string>,
-): { score: number; matchedIn: ReadonlyArray<FactMatchField> } {
-  let score = 0;
-  const matchedIn: FactMatchField[] = [];
-
-  const valueMatches = intersectionSize(queryTokens, tokenSet(fact.value));
-  if (valueMatches > 0) {
-    score += FIELD_WEIGHTS.value * valueMatches;
-    matchedIn.push("value");
-  }
-
-  const subjectMatches = intersectionSize(queryTokens, tokenSet(fact.subject));
-  if (subjectMatches > 0) {
-    score += FIELD_WEIGHTS.subject * subjectMatches;
-    matchedIn.push("subject");
-  }
-
-  const predicateMatches = intersectionSize(queryTokens, tokenSet(fact.predicate));
-  if (predicateMatches > 0) {
-    score += FIELD_WEIGHTS.predicate * predicateMatches;
-    matchedIn.push("predicate");
-  }
-
-  return { score, matchedIn };
-}
-
-function mergeHybrid(
-  kwHits: ReadonlyArray<KeywordHit>,
-  semHits: ReadonlyArray<SemanticHit>,
-  byId: ReadonlyMap<string, Fact>,
-): ReadonlyArray<FactHit> {
-  const maxKw = Math.max(1, ...kwHits.map((h) => h.score));
-  const maxSem = Math.max(1, ...semHits.map((h) => h.similarity));
-
-  const kwMap = new Map<string, KeywordHit>(kwHits.map((h) => [h.fact.id, h]));
-  const semMap = new Map<string, SemanticHit>(semHits.map((h) => [h.fact.id, h]));
-  const allIds = new Set<string>([...kwMap.keys(), ...semMap.keys()]);
-
-  const rows: FactHit[] = [];
-  for (const id of allIds) {
-    const fact = byId.get(id);
-    if (!fact) continue;
-    const kw = kwMap.get(id);
-    const sem = semMap.get(id);
-    const kwNorm = kw ? kw.score / maxKw : 0;
-    const semNorm = sem ? sem.similarity / maxSem : 0;
-    const combined = round4(HYBRID_SEM_WEIGHT * semNorm + HYBRID_KW_WEIGHT * kwNorm);
-    const matchedIn = uniqueFields(
-      kw?.matchedIn ?? [],
-      sem ? (["semantic"] as FactMatchField[]) : [],
-    );
-    rows.push({
-      ...fact,
-      matchScore: combined,
-      matchedIn,
-      keywordScore: round4(kwNorm),
-      semanticScore: round4(semNorm),
-    });
-  }
-  rows.sort((a, b) => b.matchScore - a.matchScore);
-  return rows;
-}
-
-function factToHit(
-  fact: Fact,
-  score: number,
-  matchedIn: ReadonlyArray<FactMatchField>,
-): FactHit {
-  return { ...fact, matchScore: score, matchedIn };
-}
-
-function toKeywordHit(h: KeywordHit): FactHit {
-  return factToHit(h.fact, h.score, h.matchedIn);
-}
-
-function toSemanticHit(h: SemanticHit): FactHit {
-  return factToHit(h.fact, h.similarity, ["semantic"]);
-}
-
-function finalize(
-  query: string,
-  subject: string | null,
-  predicate: string | null,
-  kind: FactRecallResult["kind"],
-  mode: RecallMode,
-  limit: number,
-  hits: ReadonlyArray<FactHit>,
-): FactRecallResult {
-  return {
-    query,
-    subject,
-    predicate,
-    kind,
-    mode,
-    limit,
-    total: hits.length,
-    results: hits.slice(0, limit),
-  };
-}
-
-function clampLimit(limit: number | undefined): number {
-  const n = limit ?? DEFAULT_LIMIT;
-  if (Number.isNaN(n) || n < 1) return 1;
-  return Math.min(MAX_LIMIT, Math.trunc(n));
-}
-
-function cosineFromL2(distance: number): number {
-  const cos = 1 - (distance * distance) / 2;
-  return round4(Math.max(-1, Math.min(1, cos)));
-}
-
-function round4(value: number): number {
-  return Math.round(value * 10_000) / 10_000;
-}
-
-function intersectionSize<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): number {
-  const [small, large] = a.size <= b.size ? [a, b] : [b, a];
-  let count = 0;
-  for (const item of small) if (large.has(item)) count += 1;
-  return count;
-}
-
-function uniqueFields(
-  a: ReadonlyArray<FactMatchField>,
-  b: ReadonlyArray<FactMatchField>,
-): ReadonlyArray<FactMatchField> {
-  const seen = new Set<FactMatchField>();
-  const out: FactMatchField[] = [];
-  for (const f of [...a, ...b]) {
-    if (!seen.has(f)) {
-      seen.add(f);
-      out.push(f);
-    }
-  }
-  return out;
-}

package/src/core/scheduler/scan-once.ts

@@ -1,142 +0,0 @@
-/**
- * scanOnce — mtime-gated incremental discovery shared by every adapter.
- *
- * The Python codebase bundled this logic into each adapter (`scan_once` +
- * `record_classified` methods). In the TS port the adapter stays a pure
- * parser (TranscriptAdapter port); the mtime check and adapter_state
- * upsert live here, generic over the adapter. Same behavior, less
- * duplication across claude-code / hermes / pi.
- *
- * Contract (per file under adapter.discover()):
- *   - If `now - mtime < idleMinutes * 60s` → still active, skip
- *   - Lookup adapter_state by (adapterName, sourcePath):
- *       no row + file idle                       → NEW: parse + return (chunk, supersedes=null)
- *       row exists, size match, failures < ceil  → UNCHANGED: skip
- *       row exists, size match, failures >= ceil → FAILED_CEILING: skip (log once per session)
- *       row exists, file grew                    → RESUMED: parse + return, reset failure_count
- *   - After successful classify+insert downstream, call `recordClassified`
- *     to upsert adapter_state with the new size + session_id.
- *   - On classify/storage failure, call `recordFailed` to increment failure_count.
- *     When failure_count reaches MAX_CLASSIFY_FAILURES and the file hasn't grown,
- *     the file is permanently skipped until new content arrives.
- */
-
-import { statSync } from "node:fs";
-import type Database from "better-sqlite3";
-import type {
-  SessionChunk,
-  TranscriptAdapter,
-} from "@ports/transcript-adapter.js";
-
-export interface ScanResult {
-  readonly chunk: SessionChunk;
-  readonly supersedes: string | null;
-}
-
-export const MAX_CLASSIFY_FAILURES = 3;
-
-interface AdapterStateRow {
-  source_path: string;
-  file_size: number | null;
-  session_id: string | null;
-  failure_count: number;
-}
-
-export async function scanOnce(
-  adapter: TranscriptAdapter,
-  idleMinutes: number,
-  db: Database.Database,
-  now: number = Date.now(),
-): Promise<ReadonlyArray<ScanResult>> {
-  const idleMs = idleMinutes * 60 * 1000;
-  const stateRows = db
-    .prepare<[string], AdapterStateRow>(
-      "SELECT source_path, file_size, session_id, COALESCE(failure_count, 0) AS failure_count FROM adapter_state WHERE adapter_name = ?",
-    )
-    .all(adapter.name);
-  const byPath = new Map<string, AdapterStateRow>(stateRows.map((r) => [r.source_path, r]));
-
-  const out: ScanResult[] = [];
-  const files = await adapter.discover();
-
-  for (const path of files) {
-    let st;
-    try {
-      st = statSync(path);
-    } catch {
-      continue;
-    }
-    const age = now - st.mtimeMs;
-    if (age < idleMs) continue;
-
-    const prior = byPath.get(path);
-    let supersedes: string | null = null;
-    if (prior) {
-      const sizeUnchanged = (prior.file_size ?? 0) === st.size;
-      if (sizeUnchanged) {
-        // File hasn't grown — skip whether clean or failed. Failures only
-        // retry when the transcript file receives new content.
-        continue;
-      }
-      // File grew: reset failure_count so resume gets a clean slate.
-      if (prior.failure_count >= MAX_CLASSIFY_FAILURES) {
-        db.prepare(
-          "UPDATE adapter_state SET failure_count = 0 WHERE adapter_name = ? AND source_path = ?",
-        ).run(adapter.name, path);
-      }
-      supersedes = prior.session_id;
-    }
-
-    const chunk = await adapter.parseSession(path);
-    if (!chunk) continue;
-    out.push({ chunk, supersedes });
-  }
-  return out;
-}
-
-export function recordClassified(
-  db: Database.Database,
-  adapterName: string,
-  sourcePath: string,
-  sessionId: string,
-): void {
-  let size = 0;
-  try {
-    size = statSync(sourcePath).size;
-  } catch {
-    return;
-  }
-  db.prepare(
-    `INSERT INTO adapter_state
-       (adapter_name, source_path, last_offset, file_size, session_id, failure_count, last_processed_at)
-     VALUES (?, ?, ?, ?, ?, 0, datetime('now'))
-     ON CONFLICT(adapter_name, source_path) DO UPDATE SET
-       last_offset = excluded.last_offset,
-       file_size = excluded.file_size,
-       session_id = excluded.session_id,
-       failure_count = 0,
-       last_processed_at = excluded.last_processed_at`,
-  ).run(adapterName, sourcePath, size, size, sessionId);
-}
-
-export function recordFailed(
-  db: Database.Database,
-  adapterName: string,
-  sourcePath: string,
-): void {
-  let size = 0;
-  try {
-    size = statSync(sourcePath).size;
-  } catch {
-    return;
-  }
-  db.prepare(
-    `INSERT INTO adapter_state
-       (adapter_name, source_path, last_offset, file_size, session_id, failure_count, last_processed_at)
-     VALUES (?, ?, ?, ?, NULL, 1, datetime('now'))
-     ON CONFLICT(adapter_name, source_path) DO UPDATE SET
-       file_size = excluded.file_size,
-       failure_count = failure_count + 1,
-       last_processed_at = excluded.last_processed_at`,
-  ).run(adapterName, sourcePath, size, size);
-}

package/src/core/scheduler/scheduler.ts

@@ -1,225 +0,0 @@
-/**
- * ScanScheduler — periodic ingest loop. Ports `scheduler.py`.
- *
- * Each tick walks the registered adapters, runs scanOnce to discover idle
- * transcript files, classifies the resulting SessionChunks via the active
- * classifier, and persists them through SqliteSessionStore.insertSession
- * with the embedder. Records adapter_state after each successful insert
- * so the next tick is incremental.
- *
- * Single-process: the scheduler runs alongside the HTTP server (Phase D
- * wires it into `nlm start`). No worker thread; Node's event loop is
- * enough — adapter discovery is filesystem-bound and the per-chunk
- * classify call is async-awaited with a wall-clock timeout to keep the
- * tick loop responsive.
- *
- * Confidence floor of 0.3 mirrors Python: classifier outputs below that
- * are skipped rather than persisted as low-quality noise.
- */
-
-import type { LLMClient } from "@ports/llm-client.js";
-import type { TranscriptAdapter } from "@ports/transcript-adapter.js";
-import { extractFacts } from "@core/facts/extract-facts.js";
-import type { SqliteFactStore } from "@core/storage/sqlite-fact-store.js";
-import type {
-  IngestRecord,
-  SqliteSessionStore,
-} from "@core/storage/sqlite-session-store.js";
-import { MAX_CLASSIFY_FAILURES, recordClassified, recordFailed, scanOnce } from "./scan-once.js";
-
-const DEFAULT_INTERVAL_MS = 30 * 60 * 1000; // 30 min, matches Python default
-const DEFAULT_CLASSIFY_TIMEOUT_MS = 120_000;
-const DEFAULT_CONFIDENCE_FLOOR = 0.3;
-const DEFAULT_IDLE_MINUTES = 15;
-const BODY_CAP = 200_000;
-
-export interface SchedulerOptions {
-  readonly store: SqliteSessionStore;
-  readonly adapters: ReadonlyArray<TranscriptAdapter>;
-  readonly classifier: LLMClient;
-  readonly embedder?: LLMClient | null;
-  /**
-   * FactStore for Phase B.2 fact ingest. When provided, the scheduler
-   * extracts facts from each classify result and persists them atomically
-   * with the session row. Optional — when null, sessions ingest as before
-   * with no facts written (backwards-compatible default for tests not yet
-   * updated, and for any future caller that wants facts off).
-   */
-  readonly factStore?: SqliteFactStore | null;
-  readonly intervalMs?: number;
-  readonly classifyTimeoutMs?: number;
-  readonly confidenceFloor?: number;
-  readonly idleMinutes?: number;
-  /** Defaults to console.error. Set to a noop in tests. */
-  readonly logger?: (msg: string) => void;
-}
-
-export interface TickReport {
-  readonly inserted: number;
-  readonly skippedLowConfidence: number;
-  readonly classifyFailures: number;
-  readonly storageFailures: number;
-  readonly chunksSeen: number;
-}
-
-export class ScanScheduler {
-  private readonly opts: Required<Omit<SchedulerOptions, "embedder" | "factStore">> & {
-    readonly embedder: LLMClient | null;
-    readonly factStore: SqliteFactStore | null;
-  };
-  private stopped = true;
-  private timer: NodeJS.Timeout | null = null;
-
-  constructor(opts: SchedulerOptions) {
-    this.opts = {
-      store: opts.store,
-      adapters: opts.adapters,
-      classifier: opts.classifier,
-      embedder: opts.embedder ?? null,
-      factStore: opts.factStore ?? null,
-      intervalMs: opts.intervalMs ?? DEFAULT_INTERVAL_MS,
-      classifyTimeoutMs: opts.classifyTimeoutMs ?? DEFAULT_CLASSIFY_TIMEOUT_MS,
-      confidenceFloor: opts.confidenceFloor ?? DEFAULT_CONFIDENCE_FLOOR,
-      idleMinutes: opts.idleMinutes ?? DEFAULT_IDLE_MINUTES,
-      logger: opts.logger ?? ((msg) => console.error(msg)),
-    };
-  }
-
-  start(): void {
-    if (!this.stopped) return;
-    this.stopped = false;
-    this.scheduleNext(0);
-  }
-
-  stop(): void {
-    this.stopped = true;
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-
-  private scheduleNext(delayMs: number): void {
-    if (this.stopped) return;
-    this.timer = setTimeout(() => {
-      void this.tick().finally(() => this.scheduleNext(this.opts.intervalMs));
-    }, delayMs);
-  }
-
-  async tick(): Promise<TickReport> {
-    let inserted = 0;
-    let skippedLowConfidence = 0;
-    let classifyFailures = 0;
-    let storageFailures = 0;
-    let chunksSeen = 0;
-
-    for (const adapter of this.opts.adapters) {
-      let results;
-      try {
-        results = await scanOnce(adapter, this.opts.idleMinutes, this.opts.store.rawDb());
-      } catch (e) {
-        this.opts.logger(
-          `[scheduler] scanOnce error for ${adapter.name}: ${e instanceof Error ? e.message : String(e)}`,
-        );
-        continue;
-      }
-
-      for (const { chunk, supersedes } of results) {
-        chunksSeen += 1;
-
-        let classification;
-        try {
-          classification = await withTimeout(
-            this.opts.classifier.classify(chunk.text),
-            this.opts.classifyTimeoutMs,
-          );
-        } catch (e) {
-          classifyFailures += 1;
-          const reason = e instanceof TimeoutError ? "timed out" : `error: ${e instanceof Error ? e.message : String(e)}`;
-          recordFailed(this.opts.store.rawDb(), adapter.name, chunk.sourcePath);
-          const failureRow = this.opts.store.rawDb()
-            .prepare<[string, string], { failure_count: number }>(
-              "SELECT COALESCE(failure_count, 0) AS failure_count FROM adapter_state WHERE adapter_name = ? AND source_path = ?",
-            )
-            .get(adapter.name, chunk.sourcePath);
-          const count = failureRow?.failure_count ?? 1;
-          const ceiling = count >= MAX_CLASSIFY_FAILURES ? ` (failure ${count}/${MAX_CLASSIFY_FAILURES} — will skip until file grows)` : ` (failure ${count}/${MAX_CLASSIFY_FAILURES})`;
-          this.opts.logger(`[scheduler] classifier ${reason} for ${chunk.id}${ceiling}`);
-          continue;
-        }
-
-        if (classification.confidence < this.opts.confidenceFloor) {
-          skippedLowConfidence += 1;
-          continue;
-        }
-
-        const record: IngestRecord = {
-          id: chunk.id,
-          runtime: chunk.runtime,
-          runtimeSessionId: chunk.runtimeSessionId || null,
-          startedAt: chunk.startedAt,
-          endedAt: chunk.endedAt || null,
-          durationMin: chunk.durationMin,
-          label: classification.label,
-          summary: classification.summary,
-          body: chunk.text.slice(0, BODY_CAP),
-          status: "closed",
-          transcriptKind: adapter.transcriptKind,
-          transcriptPath: chunk.sourcePath,
-          transcriptOffset: chunk.byteRange[0],
-          transcriptLength: chunk.byteRange[1],
-          entities: classification.entities,
-          decisions: classification.decisions,
-          openQuestions: classification.open,
-        };
-
-        const factSink = this.opts.factStore
-          ? {
-              factStore: this.opts.factStore,
-              facts: extractFacts(classification, chunk.id, chunk.startedAt),
-            }
-          : null;
-
-        try {
-          await this.opts.store.insertSession(
-            record,
-            this.opts.embedder,
-            supersedes,
-            factSink,
-          );
-          recordClassified(
-            this.opts.store.rawDb(),
-            adapter.name,
-            chunk.sourcePath,
-            chunk.id,
-          );
-          inserted += 1;
-        } catch (e) {
-          storageFailures += 1;
-          recordFailed(this.opts.store.rawDb(), adapter.name, chunk.sourcePath);
-          this.opts.logger(
-            `[scheduler] storage error for ${chunk.id}: ${e instanceof Error ? e.message : String(e)}`,
-          );
-        }
-      }
-    }
-
-    return { inserted, skippedLowConfidence, classifyFailures, storageFailures, chunksSeen };
-  }
-}
-
-class TimeoutError extends Error {}
-
-async function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
-  let timer: NodeJS.Timeout | undefined;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise<T>((_, reject) => {
-        timer = setTimeout(() => reject(new TimeoutError(`timed out after ${ms}ms`)), ms);
-      }),
-    ]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}