@remnic/core 1.1.31 → 9.3.516

package/src/graph-dashboard-diff.test.ts

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { GraphEdge } from "./graph.js";
+import type { GraphSnapshot } from "./graph-dashboard-parser.js";
+import { diffGraphSnapshots } from "./graph-dashboard-diff.js";
+
+function snapshot(edges: GraphEdge[]): GraphSnapshot {
+  return {
+    generatedAt: "2026-05-21T00:00:00.000Z",
+    nodes: [{ id: "a" }, { id: "b" }],
+    edges,
+    stats: { nodes: 2, edges: edges.length, malformedLines: 0, filesMissing: [] },
+  };
+}
+
+test("diffGraphSnapshots emits updatedEdges when existing edge confidence changes", () => {
+  const previousEdge: GraphEdge = {
+    type: "entity",
+    from: "facts/a.md",
+    to: "facts/b.md",
+    label: "person:alex",
+    ts: "2026-05-21T00:00:00.000Z",
+    weight: 1,
+    confidence: 1,
+  };
+  const nextEdge: GraphEdge = {
+    ...previousEdge,
+    confidence: 0.4,
+    lastReinforcedAt: "2026-05-21T01:00:00.000Z",
+  };
+
+  const patch = diffGraphSnapshots(snapshot([previousEdge]), snapshot([nextEdge]));
+
+  assert.equal(patch.addedEdges.length, 0);
+  assert.equal(patch.removedEdges.length, 0);
+  assert.deepEqual(patch.updatedEdges, [{ previous: previousEdge, next: nextEdge }]);
+});
+
+test("diffGraphSnapshots treats missing confidence as legacy confidence one", () => {
+  const previousEdge: GraphEdge = {
+    type: "entity",
+    from: "facts/a.md",
+    to: "facts/b.md",
+    label: "person:alex",
+    ts: "2026-05-21T00:00:00.000Z",
+    weight: 1,
+  };
+  const nextEdge: GraphEdge = {
+    ...previousEdge,
+    confidence: 1,
+  };
+
+  const patch = diffGraphSnapshots(snapshot([previousEdge]), snapshot([nextEdge]));
+
+  assert.equal(patch.updatedEdges.length, 0);
+});

package/src/graph-dashboard-diff.ts

@@ -7,6 +7,19 @@ export interface GraphPatch {
   removedNodes: string[];
   addedEdges: GraphEdge[];
   removedEdges: GraphEdge[];
+  updatedEdges: Array<{ previous: GraphEdge; next: GraphEdge }>;
+}
+
+function compareGraphEdges(a: GraphEdge, b: GraphEdge): number {
+  return a.type.localeCompare(b.type) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to);
+}
+
+function edgeFieldsChanged(previous: GraphEdge, next: GraphEdge): boolean {
+  return (
+    previous.weight !== next.weight ||
+    (previous.confidence ?? 1) !== (next.confidence ?? 1) ||
+    (previous.lastReinforcedAt ?? null) !== (next.lastReinforcedAt ?? null)
+  );
 }
 
 export function diffGraphSnapshots(previous: GraphSnapshot, next: GraphSnapshot): GraphPatch {
@@ -20,16 +33,25 @@ export function diffGraphSnapshots(previous: GraphSnapshot, next: GraphSnapshot)
   const addedEdges = [...nextEdges.entries()]
     .filter(([key]) => !prevEdges.has(key))
     .map(([, edge]) => edge)
-    .sort((a, b) => a.type.localeCompare(b.type) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+    .sort(compareGraphEdges);
   const removedEdges = [...prevEdges.entries()]
     .filter(([key]) => !nextEdges.has(key))
     .map(([, edge]) => edge)
-    .sort((a, b) => a.type.localeCompare(b.type) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+    .sort(compareGraphEdges);
+  const updatedEdges = [...nextEdges.entries()]
+    .flatMap(([key, nextEdge]) => {
+      const previousEdge = prevEdges.get(key);
+      return previousEdge && edgeFieldsChanged(previousEdge, nextEdge)
+        ? [{ previous: previousEdge, next: nextEdge }]
+        : [];
+    })
+    .sort((a, b) => compareGraphEdges(a.next, b.next));
 
   return {
     addedNodes,
     removedNodes,
     addedEdges,
     removedEdges,
+    updatedEdges,
   };
 }

package/src/graph-dashboard-parser.test.ts

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { graphSnapshotFromMemoryDir } from "./graph-dashboard-parser.js";
+
+test("graphSnapshotFromMemoryDir reports only absent graph files as missing", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-parser-missing-"));
+  try {
+    const snapshot = await graphSnapshotFromMemoryDir(memoryDir);
+    assert.deepEqual(snapshot.stats.filesMissing, ["entity", "time", "causal"]);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("graphSnapshotFromMemoryDir throws for unreadable graph file paths", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-parser-unreadable-"));
+  try {
+    await mkdir(path.join(memoryDir, "state", "graphs", "entity.jsonl"), { recursive: true });
+
+    await assert.rejects(
+      () => graphSnapshotFromMemoryDir(memoryDir),
+      (err: unknown) => (err as NodeJS.ErrnoException).code === "EISDIR",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/graph-dashboard-parser.ts

@@ -55,7 +55,10 @@ export async function graphSnapshotFromMemoryDir(memoryDir: string): Promise<Gra
     let raw = "";
     try {
       raw = await readFile(filePath, "utf-8");
-    } catch {
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        throw err;
+      }
       filesMissing.push(type);
       continue;
     }

package/src/graph-events.ts

@@ -118,10 +118,12 @@ export function emitGraphEvent(
     payload,
   };
   const bus = getGraphEventBus(memoryDir);
-  try {
-    bus.emit("graph-event", event);
-  } catch {
-    // fail-open: never propagate listener errors to the write path
+  for (const listener of bus.listeners("graph-event")) {
+    try {
+      (listener as (event: GraphEvent) => void)(event);
+    } catch {
+      // fail-open: never let one subscriber block later listeners or writes
+    }
   }
 }
 

package/src/graph.test.ts

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+
+import {
+  GraphIndex,
+  graphFilePath,
+  readEdges,
+  type GraphConfig,
+} from "./graph.js";
+
+function makeGraphConfig(): GraphConfig {
+  return {
+    multiGraphMemoryEnabled: true,
+    entityGraphEnabled: true,
+    timeGraphEnabled: false,
+    causalGraphEnabled: false,
+    maxGraphTraversalSteps: 2,
+    graphActivationDecay: 0.5,
+    maxEntityGraphEdgesPerMemory: 10,
+    graphLateralInhibitionEnabled: false,
+    graphLateralInhibitionBeta: 0,
+    graphLateralInhibitionTopM: 0,
+    graphTraversalConfidenceFloor: 0.2,
+    graphTraversalPageRankIterations: 0,
+  };
+}
+
+test("graph reads skip malformed JSON edge objects before traversal", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-malformed-"));
+  try {
+    const filePath = graphFilePath(memoryDir, "entity");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(
+      filePath,
+      [
+        JSON.stringify({
+          from: "a",
+          type: "entity",
+          weight: 1,
+          label: "broken",
+          ts: "2026-01-01T00:00:00.000Z",
+        }),
+        JSON.stringify({
+          from: "a",
+          to: "c",
+          type: "entity",
+          weight: 1,
+          label: "valid",
+          ts: "2026-01-01T00:00:00.000Z",
+        }),
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const edges = await readEdges(memoryDir, "entity");
+    assert.deepEqual(edges.map((edge) => edge.to), ["c"]);
+
+    const graph = new GraphIndex(memoryDir, makeGraphConfig());
+    const activated = await graph.spreadingActivation(["a"]);
+    assert.deepEqual(activated.map((candidate) => candidate.path), ["c"]);
+    assert.equal(Number.isFinite(activated[0]?.score), true);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/graph.ts

@@ -144,13 +144,16 @@ function isNodeError(err: unknown): err is NodeJS.ErrnoException {
   return typeof err === "object" && err !== null && "code" in err;
 }
 
-function parseEdgesJsonl(raw: string): GraphEdge[] {
+function parseEdgesJsonl(raw: string, expectedType: GraphType): GraphEdge[] {
   const edges: GraphEdge[] = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
-      edges.push(JSON.parse(trimmed) as GraphEdge);
+      const parsed = JSON.parse(trimmed) as unknown;
+      if (isValidGraphEdge(parsed, expectedType)) {
+        edges.push(parsed);
+      }
     } catch {
       // skip corrupt lines — fail-open for partial JSONL recovery
     }
@@ -171,7 +174,7 @@ export async function readEdges(memoryDir: string, type: GraphType): Promise<Gra
   const filePath = graphFilePath(memoryDir, type);
   try {
     const raw = await readFile(filePath, "utf8");
-    return parseEdgesJsonl(raw);
+    return parseEdgesJsonl(raw, type);
   } catch {
     return [];
   }
@@ -188,7 +191,7 @@ export async function readEdgesStrict(memoryDir: string, type: GraphType): Promi
   const filePath = graphFilePath(memoryDir, type);
   try {
     const raw = await readFile(filePath, "utf8");
-    return parseEdgesJsonl(raw);
+    return parseEdgesJsonl(raw, type);
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return [];

package/src/importers/base.test.ts

@@ -150,6 +150,29 @@ describe("importedMemoryToTurn", () => {
     const turn = importedMemoryToTurn(memory);
     assert.equal(turn.participantId, "cg-abc-123");
   });
+
+  it("preserves importer provenance separately from the ingest timestamp", () => {
+    const memory: ImportedMemory = {
+      content: "hello",
+      sourceLabel: "chatgpt",
+      sourceId: "cg-abc-123",
+      sourceTimestamp: "2026-04-10T14:25:07.000Z",
+      importedAt: "2026-05-20T00:00:00.000Z",
+      importedFromPath: "/tmp/chatgpt-export.json",
+      metadata: { conversationId: "conv-1", tags: ["saved"] },
+    };
+
+    const turn = importedMemoryToTurn(memory);
+    assert.equal(turn.timestamp, "2026-04-10T14:25:07.000Z");
+    assert.deepEqual(turn.importProvenance, {
+      sourceLabel: "chatgpt",
+      sourceId: "cg-abc-123",
+      sourceTimestamp: "2026-04-10T14:25:07.000Z",
+      importedFromPath: "/tmp/chatgpt-export.json",
+      importedAt: "2026-05-20T00:00:00.000Z",
+      metadata: { conversationId: "conv-1", tags: ["saved"] },
+    });
+  });
 });
 
 describe("runImporter — slice 1 integration", () => {
@@ -211,6 +234,8 @@ describe("runImporter — slice 1 integration", () => {
       for (const turn of batch) {
         assert.equal(turn.role, "user");
         assert.equal(turn.participantName, "chatgpt");
+        assert.equal(turn.importProvenance?.importedFromPath, "/tmp/fake-export.json");
+        assert.equal(turn.importProvenance?.sourceLabel, "chatgpt");
       }
     }
   });
@@ -273,6 +298,51 @@ describe("runImporter — slice 1 integration", () => {
     );
   });
 
+  it("rejects malformed transformed memories before writeTo is called", async () => {
+    const { target, received } = makeMockTarget();
+    let writeToCalls = 0;
+    const adapter: ImporterAdapter<unknown> = {
+      name: "bad-memory",
+      sourceLabel: "chatgpt",
+      parse: (input) => input,
+      transform: () => [
+        {
+          content: "",
+          sourceLabel: "chatgpt",
+          sourceTimestamp: "not-a-date",
+        } as ImportedMemory,
+      ],
+      async writeTo(t, batch) {
+        writeToCalls += 1;
+        return defaultWriteMemoriesToOrchestrator(t, batch);
+      },
+    };
+
+    await assert.rejects(
+      () => runImporter(adapter, {}, target),
+      /Importer 'bad-memory' produced invalid memory at index 0: .*content.*timestamp/s,
+    );
+    assert.equal(writeToCalls, 0);
+    assert.equal(received.length, 0);
+  });
+
+  it("default writer rejects invalid imported memories before ingesting turns", async () => {
+    const { target, received } = makeMockTarget();
+
+    await assert.rejects(
+      () =>
+        defaultWriteMemoriesToOrchestrator(target, [
+          {
+            content: "valid content",
+            sourceLabel: "",
+            importedAt: "not-a-date",
+          },
+        ]),
+      /defaultWriteMemoriesToOrchestrator.*sourceLabel.*timestamp/s,
+    );
+    assert.equal(received.length, 0);
+  });
+
   it("fills in a missing sourceLabel from the adapter default", async () => {
     const memories: ImportedMemory[] = [
       // sourceLabel deliberately empty — runImporter should fall back.

package/src/importers/base.ts

@@ -26,7 +26,7 @@
 // intended for the four memory sources in #568 — they emit *memories*
 // (intent-level content) rather than raw conversation turns.
 
-import type { ImportTurn } from "../bulk-import/types.js";
+import { validateImportTurn, type ImportTurn } from "../bulk-import/types.js";
 
 /**
  * A single imported memory record with provenance.
@@ -217,6 +217,8 @@ export interface ImporterTransformOptions {
   includeConversations?: boolean;
   /** Maximum number of memories to emit. Primarily for tests. */
   maxMemories?: number;
+  /** Adapter-specific minimum source text length for importers that filter tiny prompts. */
+  minPromptLength?: number;
 }
 
 // ---------------------------------------------------------------------------
@@ -295,9 +297,46 @@ export function importedMemoryToTurn(memory: ImportedMemory): ImportTurn {
     timestamp,
     participantName: memory.sourceLabel,
     ...(memory.sourceId !== undefined ? { participantId: memory.sourceId } : {}),
+    importProvenance: {
+      sourceLabel: memory.sourceLabel,
+      ...(memory.sourceId !== undefined ? { sourceId: memory.sourceId } : {}),
+      ...(memory.sourceTimestamp !== undefined ? { sourceTimestamp: memory.sourceTimestamp } : {}),
+      ...(memory.importedFromPath !== undefined ? { importedFromPath: memory.importedFromPath } : {}),
+      ...(memory.importedAt !== undefined ? { importedAt: memory.importedAt } : {}),
+      ...(memory.metadata !== undefined ? { metadata: memory.metadata } : {}),
+    },
   };
 }
 
+function invalidImportedMemoryError(
+  adapterName: string,
+  index: number,
+  issues: string[],
+): Error {
+  return new Error(
+    `Importer '${adapterName}' produced invalid memory at index ${index}: ${issues.join("; ")}`,
+  );
+}
+
+function validateImportedMemory(
+  memory: ImportedMemory,
+  adapterName: string,
+  index: number,
+): void {
+  const issues: string[] = [];
+  if (typeof memory.sourceLabel !== "string" || memory.sourceLabel.trim().length === 0) {
+    issues.push("sourceLabel must be a non-empty string");
+  }
+  issues.push(
+    ...validateImportTurn(importedMemoryToTurn(memory), index).map(
+      (issue) => issue.message,
+    ),
+  );
+  if (issues.length > 0) {
+    throw invalidImportedMemoryError(adapterName, index, issues);
+  }
+}
+
 export interface RunImporterResult {
   adapter: string;
   sourceLabel: string;
@@ -362,17 +401,24 @@ export async function runImporter<Parsed>(
         "Adapters must produce ImportedMemory[].",
     );
   }
-  const memories = memoriesRaw.map((memory) => {
+  const memories = memoriesRaw.map((memory, index) => {
+    if (memory === null || typeof memory !== "object") {
+      throw invalidImportedMemoryError(adapter.name, index, [
+        "memory must be an object",
+      ]);
+    }
+    const record = memory as ImportedMemory;
     const sourceLabel =
-      typeof memory.sourceLabel === "string" && memory.sourceLabel.length > 0
-        ? memory.sourceLabel
-        : adapter.sourceLabel;
+      typeof record.sourceLabel === "string" && record.sourceLabel.trim().length > 0
+        ? record.sourceLabel.trim()
+        : adapter.sourceLabel.trim();
     return {
-      ...memory,
+      ...record,
       sourceLabel,
-      importedAt: memory.importedAt ?? importedAt,
+      importedAt: record.importedAt ?? importedAt,
     };
   });
+  memories.forEach((memory, index) => validateImportedMemory(memory, adapter.name, index));
 
   // Phase 3 — write (or dry-run plan)
   if (dryRun) {
@@ -430,6 +476,9 @@ export async function defaultWriteMemoriesToOrchestrator(
   if (memories.length === 0) {
     return { memoriesIngested: 0 };
   }
+  memories.forEach((memory, index) =>
+    validateImportedMemory(memory, "defaultWriteMemoriesToOrchestrator", index),
+  );
   const turns = memories.map(importedMemoryToTurn);
   await target.ingestBulkImportBatch(turns);
   return { memoriesIngested: memories.length };

package/src/index.ts

@@ -17,10 +17,10 @@
  */
 
 // ---------------------------------------------------------------------------
-// Plugin identity
+// Plugin entry resolution
 // ---------------------------------------------------------------------------
 
-export { PLUGIN_ID, LEGACY_PLUGIN_ID, resolveRemnicPluginEntry } from "./plugin-id.js";
+export { resolvePluginEntry, type PluginEntryResolverOptions } from "./plugin-entry-resolver.js";
 
 // ---------------------------------------------------------------------------
 // Configuration
@@ -1017,7 +1017,10 @@ export {
   clearBulkImportSources,
   runBulkImportPipeline,
   formatBatchTranscript,
+  validateBatchSize,
+  resolveBulkImportContext,
   type ProcessBatchFn,
+  type ProcessBatchContext,
   type ProcessBatchResult,
 } from "./bulk-import/index.js";
 

package/src/lcm/archive.ts

@@ -53,6 +53,19 @@ export function estimateTokens(text: string): number {
   return Math.ceil(text.length / 4);
 }
 
+const PUBLIC_LCM_SEARCH_LIMIT = 100;
+
+function normalizeSearchLimit(limit: number, fallback = 10, max = PUBLIC_LCM_SEARCH_LIMIT): number {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) return fallback;
+  const normalized = Math.floor(limit);
+  if (normalized <= 0) return 0;
+  return Math.min(max, normalized);
+}
+
+function escapeSqlLike(value: string): string {
+  return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+
 export class LcmArchive {
   constructor(private readonly db: Database.Database) {}
 
@@ -193,10 +206,12 @@ export class LcmArchive {
   }
 
   /** Full-text search across all messages. */
-  search(query: string, limit: number, sessionId?: string): LcmSearchResult[] {
+  search(query: string, limit: number, sessionId?: string, sessionPrefix?: string): LcmSearchResult[] {
     try {
       const ftsQuery = sanitizeFtsQuery(query);
       if (!ftsQuery) return [];
+      const cappedLimit = normalizeSearchLimit(limit);
+      if (cappedLimit === 0) return [];
 
       let sql: string;
       const params: unknown[] = [ftsQuery];
@@ -212,7 +227,19 @@ export class LcmArchive {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(sessionId, limit);
+        params.push(sessionId, cappedLimit);
+      } else if (sessionPrefix) {
+        sql = `
+          SELECT m.turn_index, m.role, snippet(lcm_messages_fts, 0, '>>>', '<<<', '...', 48) as snippet,
+                 m.session_id, rank
+          FROM lcm_messages_fts f
+          JOIN lcm_messages m ON m.id = f.rowid
+          WHERE lcm_messages_fts MATCH ?
+            AND m.session_id LIKE ? ESCAPE '\\'
+          ORDER BY rank
+          LIMIT ?
+        `;
+        params.push(`${escapeSqlLike(sessionPrefix)}%`, cappedLimit);
       } else {
         sql = `
           SELECT m.turn_index, m.role, snippet(lcm_messages_fts, 0, '>>>', '<<<', '...', 48) as snippet,
@@ -223,7 +250,7 @@ export class LcmArchive {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(limit);
+        params.push(cappedLimit);
       }
 
       const rows = this.db.prepare(sql).all(...params) as Array<{
@@ -252,10 +279,12 @@ export class LcmArchive {
    * Returns ~1000-char windows centered on query term matches.
    * Deduplicates by message id and returns results sorted by FTS rank.
    */
-  searchWithContent(query: string, limit: number, sessionId?: string, excerptChars = 1000): LcmSearchWithContentResult[] {
+  searchWithContent(query: string, limit: number, sessionId?: string, excerptChars = 1000, sessionPrefix?: string): LcmSearchWithContentResult[] {
     try {
       const ftsQuery = sanitizeFtsQuery(query);
       if (!ftsQuery) return [];
+      const cappedLimit = normalizeSearchLimit(limit);
+      if (cappedLimit === 0) return [];
 
       // Extract content words from query for excerpt windowing
       const queryWords = query
@@ -277,7 +306,18 @@ export class LcmArchive {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(sessionId, limit);
+        params.push(sessionId, cappedLimit);
+      } else if (sessionPrefix) {
+        sql = `
+          SELECT m.id, m.turn_index, m.role, m.content, m.session_id, rank
+          FROM lcm_messages_fts f
+          JOIN lcm_messages m ON m.id = f.rowid
+          WHERE lcm_messages_fts MATCH ?
+            AND m.session_id LIKE ? ESCAPE '\\'
+          ORDER BY rank
+          LIMIT ?
+        `;
+        params.push(`${escapeSqlLike(sessionPrefix)}%`, cappedLimit);
       } else {
         sql = `
           SELECT m.id, m.turn_index, m.role, m.content, m.session_id, rank
@@ -287,7 +327,7 @@ export class LcmArchive {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(limit);
+        params.push(cappedLimit);
       }
 
       const rows = this.db.prepare(sql).all(...params) as Array<{
@@ -431,17 +471,26 @@ export class LcmArchive {
   pruneOldMessages(retentionDays: number): number {
     const cutoff = new Date(Date.now() - retentionDays * 86400_000).toISOString();
 
-    // Delete from FTS first
-    this.db
-      .prepare(
-        "DELETE FROM lcm_messages_fts WHERE rowid IN (SELECT id FROM lcm_messages WHERE created_at < ?)",
-      )
-      .run(cutoff);
+    const txn = this.db.transaction(() => {
+      // Delete from FTS and child tables first. Some handles may not have
+      // foreign_keys enabled, so do not rely on ON DELETE CASCADE for parts.
+      this.db
+        .prepare(
+          "DELETE FROM lcm_messages_fts WHERE rowid IN (SELECT id FROM lcm_messages WHERE created_at < ?)",
+        )
+        .run(cutoff);
+      this.db
+        .prepare(
+          "DELETE FROM lcm_message_parts WHERE message_id IN (SELECT id FROM lcm_messages WHERE created_at < ?)",
+        )
+        .run(cutoff);
 
-    const result = this.db
-      .prepare("DELETE FROM lcm_messages WHERE created_at < ?")
-      .run(cutoff);
-    return result.changes;
+      const result = this.db
+        .prepare("DELETE FROM lcm_messages WHERE created_at < ?")
+        .run(cutoff);
+      return result.changes;
+    });
+    return txn();
   }
 }