@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/memory/db-maintenance.ts

@@ -58,11 +58,10 @@ async function runDbMaintenance(): Promise<void> {
   );
 
   // Prune finished workflow runs (and their journals) past the retention
-  // window BEFORE VACUUM so the freed pages are reclaimed in the same pass.
-  // This is a fast bounded DELETE on the small workflow tables, so it runs on
-  // the main connection (`rawRun`) — unlike VACUUM/optimize it doesn't need the
-  // async/subprocess path. The maintenance scheduler below already defers this
-  // whole routine to an idle window.
+  // window. This is a fast bounded DELETE on the small workflow tables, so it
+  // runs on the main connection (`rawRun`). SQLite reuses the pages it frees
+  // for later writes — we deliberately do not VACUUM to hand them back to the
+  // OS (see the WAL note below).
   try {
     const deletedRuns = pruneRuns(getConfig().workflows.journalRetentionDays);
     if (deletedRuns > 0) {
@@ -72,18 +71,9 @@ async function runDbMaintenance(): Promise<void> {
     log.warn({ err }, "Workflow run pruning failed (non-fatal)");
   }
 
-  // VACUUM is the long-running one — minutes on a multi-GB DB. PRAGMA
-  // optimize is fast but routed through the same async path for
-  // consistency and to keep both off the main thread when the CLI
-  // backend is available.
-  const vacuumResult = await runAsyncSqlite("VACUUM");
-  if (!vacuumResult.ok) {
-    log.warn(
-      { error: vacuumResult.error, backend: vacuumResult.backend },
-      "VACUUM failed (non-fatal)",
-    );
-  }
-
+  // Refresh the query planner's statistics. PRAGMA optimize is cheap; it is
+  // routed through the async path for consistency and to keep it off the main
+  // thread when the sqlite3 CLI backend is available.
   const optimizeResult = await runAsyncSqlite("PRAGMA optimize");
   if (!optimizeResult.ok) {
     log.warn(
@@ -92,26 +82,42 @@ async function runDbMaintenance(): Promise<void> {
     );
   }
 
-  const after = getDbStats();
-  const reclaimedPages = before.pageCount - after.pageCount;
-  const reclaimedBytes =
-    before.fileSizeBytes != null && after.fileSizeBytes != null
-      ? before.fileSizeBytes - after.fileSizeBytes
-      : null;
+  // Truncate the WAL so it doesn't sit at its high-water mark. We intentionally
+  // do NOT run a full VACUUM: in WAL mode VACUUM rewrites the whole database
+  // through the WAL, inflating it to ~the database size and needing up to 2x the
+  // DB size in free disk to finish. SQLite already reuses freed pages for new
+  // writes, so eager space return isn't worth that cost on a multi-GB database.
+  //
+  // The checkpoint goes through the async path (sqlite3 subprocess when one is
+  // available) for the same reason VACUUM/optimize do: a synchronous
+  // wal_checkpoint(TRUNCATE) on the shared connection blocks the event loop
+  // while it checkpoints frames and waits out readers — the health/IPC stall
+  // runAsyncSqlite exists to avoid. A checkpoint from a separate connection
+  // still truncates the shared WAL; if a reader holds it back it's a
+  // best-effort no-op and the next maintenance pass retries.
+  const checkpointResult = await runAsyncSqlite(
+    "PRAGMA wal_checkpoint(TRUNCATE)",
+  );
+  if (!checkpointResult.ok) {
+    log.warn(
+      { error: checkpointResult.error, backend: checkpointResult.backend },
+      "WAL checkpoint failed (non-fatal)",
+    );
+  }
 
+  const after = getDbStats();
   log.info(
     {
-      backend: vacuumResult.backend,
-      vacuumOk: vacuumResult.ok,
       optimizeOk: optimizeResult.ok,
-      vacuumElapsedMs: vacuumResult.elapsedMs,
+      optimizeBackend: optimizeResult.backend,
       optimizeElapsedMs: optimizeResult.elapsedMs,
-      beforePageCount: before.pageCount,
-      afterPageCount: after.pageCount,
-      reclaimedPages,
-      beforeFileSizeBytes: before.fileSizeBytes,
-      afterFileSizeBytes: after.fileSizeBytes,
-      reclaimedBytes,
+      checkpointOk: checkpointResult.ok,
+      checkpointBackend: checkpointResult.backend,
+      checkpointResult: checkpointResult.stdout?.trim(),
+      checkpointElapsedMs: checkpointResult.elapsedMs,
+      pageCount: after.pageCount,
+      freelistCount: after.freelistCount,
+      fileSizeBytes: after.fileSizeBytes,
     },
     "Database maintenance complete",
   );
@@ -126,12 +132,11 @@ export async function maybeRunDbMaintenance(nowMs = Date.now()): Promise<void> {
   );
   if (nowMs - lastRun < intervalMs) return;
 
-  // VACUUM holds an exclusive lock on the database for its full duration —
-  // minutes on a multi-GB DB — during which every other write fails with
-  // SQLITE_BUSY ("database is locked"). Defer maintenance until the user has
-  // been quiet for `quietPeriodMs` so that lock never lands mid-conversation.
-  // The checkpoint below is only written once maintenance actually runs, so a
-  // deferred run is simply retried on a later (still-idle) worker tick.
+  // Maintenance still takes brief write locks (PRAGMA optimize and the
+  // truncating WAL checkpoint), so defer it until the user has been quiet for
+  // `quietPeriodMs` and those locks never land mid-conversation. The checkpoint
+  // below is only written once maintenance actually runs, so a deferred run is
+  // simply retried on a later (still-idle) worker tick.
   if (quietPeriodMs > 0) {
     const lastUserMessageAt = getLastUserMessageTimestamp();
     if (lastUserMessageAt > 0 && nowMs - lastUserMessageAt < quietPeriodMs) {

package/src/memory/db-singleton.ts

@@ -1,15 +1,20 @@
 /**
- * Holds the assistant DB connection singleton and its close callback.
+ * Holds the assistant DB connection singletons and their close callbacks.
  *
- * Lives in its own module (rather than alongside the resolver in
- * `db-connection.ts`) so test code can reset the singleton without
+ * Three connections live here under the same `globalThis.vellumAssistant`
+ * namespace, keyed by slot: the `main` daemon connection, the `logs`
+ * connection (`assistant-logs.db`), and the `memory` connection
+ * (`assistant-memory.db`). Each is opened lazily by `db-connection.ts`.
+ *
+ * Lives in its own module (rather than alongside the resolvers in
+ * `db-connection.ts`) so test code can reset the singletons without
  * importing `db-connection.ts` — which transitively pulls
  * `drizzle-orm/bun-sqlite`. Stdlib-only by design: this file must remain
  * safe to import from the test preload's load-time chain, where a broken
  * `node_modules` symlink has historically tripped the env override
  * (see DB ghost #3, /workspace/journal/2026-05-25-db-ghost-3-recovery.md).
  *
- * State is held on `globalThis.vellumAssistant.dbSingleton` so test
+ * State is held on `globalThis.vellumAssistant.dbSingletons` so test
  * helpers in `__tests__/` can read/write it WITHOUT importing this
  * module — they declare the same slot shape locally and access the
  * globalThis namespace directly. See
@@ -21,50 +26,71 @@
  * parameter on `getStoredDb<DrizzleDb>()`.
  *
  * Consumers:
- *   - `db-connection.ts` (opens/owns the connection)
- *   - production callers that need to close the active connection
+ *   - `db-connection.ts` (opens/owns the connections)
+ *   - production callers that need to close the active connections
  *     (migration routes, vbundle import, backup/restore, daemon shutdown)
  *   - `__tests__/db-test-helpers.ts` (per-test reset, via globalThis)
  */
 
+/** Which connection a slot holds. */
+export type DbSlotKey = "main" | "logs" | "memory";
+
 type DbSlot = {
   db: unknown;
   closer: (() => void) | null;
 };
 
+type DbSlots = Record<DbSlotKey, DbSlot>;
+
 type VellumAssistantNamespace = {
-  dbSingleton?: DbSlot;
+  dbSingletons?: DbSlots;
 };
 
-function slot(): DbSlot {
+function emptySlot(): DbSlot {
+  return { db: null, closer: null };
+}
+
+function slots(): DbSlots {
   const g = globalThis as { vellumAssistant?: VellumAssistantNamespace };
   const ns = (g.vellumAssistant ??= {});
-  return (ns.dbSingleton ??= { db: null, closer: null });
+  return (ns.dbSingletons ??= {
+    main: emptySlot(),
+    logs: emptySlot(),
+    memory: emptySlot(),
+  });
+}
+
+function slot(key: DbSlotKey): DbSlot {
+  return slots()[key];
 }
 
-/** Read the current singleton, narrowed to `T`. `null` means not yet opened. */
-export function getStoredDb<T>(): T | null {
-  return slot().db as T | null;
+/** Read the current singleton for `key`, narrowed to `T`. `null` means not yet opened. */
+export function getStoredDb<T>(key: DbSlotKey): T | null {
+  return slot(key).db as T | null;
 }
 
 /**
  * Store a freshly-opened connection and the closer to run on
- * `clearStoredDb()`. The closer must be self-contained — it is invoked
+ * `clearStoredDb(key)`. The closer must be self-contained — it is invoked
  * inside a try/catch, so partial failures are swallowed (best-effort
  * close on shutdown / restore paths).
  */
-export function setStoredDb<T>(newDb: T, close: () => void): void {
-  const s = slot();
+export function setStoredDb<T>(
+  key: DbSlotKey,
+  newDb: T,
+  close: () => void,
+): void {
+  const s = slot(key);
   s.db = newDb;
   s.closer = close;
 }
 
 /**
- * Close the active connection (if any) via the stored closer, then drop
- * both. Idempotent: safe to call when no connection is stored.
+ * Close the active connection for `key` (if any) via the stored closer,
+ * then drop both. Idempotent: safe to call when no connection is stored.
  */
-export function clearStoredDb(): void {
-  const s = slot();
+export function clearStoredDb(key: DbSlotKey): void {
+  const s = slot(key);
   if (s.closer) {
     try {
       s.closer();

package/src/memory/fork-message-copy.ts

@@ -0,0 +1,170 @@
+// ---------------------------------------------------------------------------
+// Fork message-copy — off-event-loop bulk copy of a conversation's messages.
+// ---------------------------------------------------------------------------
+//
+// The fork-based memory retrospective copies the entire source conversation's
+// message rows into a throwaway background conversation. Done in-process via
+// `bun:sqlite` (synchronous), that copy is the single longest uninterruptible
+// block on the daemon's event loop — on a multi-GB database it pegs the CPU
+// for minutes, stalling `/healthz` and the gateway's IPC calls (see the
+// runtime-freeze investigation).
+//
+// This module moves the message-row copy off the event loop via
+// {@link runAsyncSqlite}, which runs the statements in a `sqlite3` CLI
+// subprocess (its own connection; SQLite file-locking arbitrates with the
+// in-process handle). The content/metadata never round-trip through JS — they
+// are copied SELECT→INSERT inside SQLite — so there is no string-escaping
+// hazard and the heavy bytes stay in the database.
+//
+// Two properties matter for correctness:
+//
+//   1. **Lock-friendly batching.** The main connection runs `busy_timeout=5000`
+//      (`db-connection.ts`). A single `INSERT … SELECT` over the whole history
+//      is one implicit transaction that holds the write lock for its full
+//      duration — a concurrent in-process write (a live user turn persisting a
+//      message) would then block up to 5 s and throw `SQLITE_BUSY`. So the copy
+//      is split into batches that each auto-commit, releasing the lock between
+//      batches so in-process writers slip in.
+//
+//   2. **`cloneForkMessageMetadata` parity.** The in-process fork stamps
+//      `forkSourceMessageId` onto each copied row's metadata. The SQL `CASE`
+//      below is a faithful translation of that helper's three branches
+//      (object → preserve-or-stamp; null/non-object/invalid → fresh object).
+//      `client_message_id` is intentionally NOT copied, matching the
+//      in-process fork (a forked row is not a client-submitted message).
+
+import { type AsyncSqliteResult, runAsyncSqlite } from "./db-async-query.js";
+
+/**
+ * Default batch size for the chunked copy. Each batch is one `INSERT … SELECT`
+ * that auto-commits, so this bounds how long the subprocess holds the write
+ * lock before releasing it to in-process writers. Small enough to keep the
+ * lock-hold window short on a bloated database; large enough that per-batch
+ * statement overhead stays negligible against the row copy.
+ */
+export const DEFAULT_FORK_COPY_BATCH_SIZE = 500;
+
+/**
+ * A single source→fork message-id mapping. `oldId` is an existing source
+ * message id; `newId` is the freshly-generated id the fork row will carry.
+ * Generated by the caller (in JS) so the same map drives both this copy and
+ * the in-process attachment relink that follows.
+ */
+export interface ForkIdPair {
+  oldId: string;
+  newId: string;
+}
+
+export interface CopyForkMessagesOptions {
+  /** The fork conversation id every copied row is assigned to. */
+  forkConversationId: string;
+  /** Ordered source→fork id pairs for every message to copy. */
+  idPairs: readonly ForkIdPair[];
+  /** Override the per-batch row count (see {@link DEFAULT_FORK_COPY_BATCH_SIZE}). */
+  batchSize?: number;
+  /** Test-only passthrough to force the in-process backend. */
+  forceInProcess?: boolean;
+}
+
+// Server-generated ids only ever use this charset. We interpolate ids (never
+// message content) into the SQL script, so reject anything outside it as a
+// defense-in-depth guard against a malformed id breaking out of the literal.
+const SAFE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+
+function assertSafeId(id: string): void {
+  if (!SAFE_ID.test(id)) {
+    throw new Error(
+      `fork message-copy: unsafe id literal: ${JSON.stringify(id)}`,
+    );
+  }
+}
+
+/**
+ * SQL translation of `cloneForkMessageMetadata`. `m` is the source `messages`
+ * row alias; the stamped value is the SOURCE message id (`m.id`), preserving an
+ * existing `forkSourceMessageId` when the metadata is already an object.
+ */
+const METADATA_CLONE_EXPR = `CASE
+  WHEN json_valid(m.metadata) AND json_type(m.metadata) = 'object'
+    THEN json_set(m.metadata, '$.forkSourceMessageId',
+      coalesce(json_extract(m.metadata, '$.forkSourceMessageId'), m.id))
+  ELSE json_object('forkSourceMessageId', m.id)
+END`;
+
+/**
+ * Build the multi-statement SQL script that copies the given id pairs into the
+ * fork conversation in lock-friendly batches. Exported for unit testing the
+ * generated SQL without spawning a subprocess.
+ */
+export function buildForkCopyScript(options: CopyForkMessagesOptions): string {
+  const { forkConversationId, idPairs } = options;
+  assertSafeId(forkConversationId);
+  const batchSize = Math.max(
+    1,
+    options.batchSize ?? DEFAULT_FORK_COPY_BATCH_SIZE,
+  );
+
+  const statements: string[] = [
+    // Connection-scoped staging table holding the current batch's id map. The
+    // unqualified `messages` reference in the SELECT resolves to the main DB.
+    `CREATE TEMP TABLE IF NOT EXISTS _fork_id_map (old_id TEXT PRIMARY KEY, new_id TEXT NOT NULL);`,
+  ];
+
+  for (let i = 0; i < idPairs.length; i += batchSize) {
+    const batch = idPairs.slice(i, i + batchSize);
+    const values = batch
+      .map(({ oldId, newId }) => {
+        assertSafeId(oldId);
+        assertSafeId(newId);
+        return `('${oldId}','${newId}')`;
+      })
+      .join(",");
+
+    // Each batch auto-commits (no surrounding BEGIN), so the write lock is
+    // released between batches for in-process writers.
+    statements.push(`DELETE FROM _fork_id_map;`);
+    statements.push(
+      `INSERT INTO _fork_id_map (old_id, new_id) VALUES ${values};`,
+    );
+    statements.push(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at, metadata)
+SELECT map.new_id, '${forkConversationId}', m.role, m.content, m.created_at, ${METADATA_CLONE_EXPR}
+FROM messages m JOIN _fork_id_map map ON map.old_id = m.id;`,
+    );
+  }
+
+  // Drop the staging table so the in-process fallback (which runs on the shared
+  // daemon connection) does not leave it lingering; harmless for the subprocess
+  // backend, whose connection is discarded on exit.
+  statements.push(`DROP TABLE IF EXISTS _fork_id_map;`);
+
+  return statements.join("\n");
+}
+
+/**
+ * Copy the message rows for a fork off the event loop, in lock-friendly
+ * batches. Resolves once every batch has committed (or rejects via the
+ * returned result's `ok: false` on subprocess failure — the caller is
+ * responsible for cleaning up the partially-built fork).
+ *
+ * No-op (returns a synthetic ok result) when there is nothing to copy.
+ */
+export async function copyForkMessagesViaSubprocess(
+  options: CopyForkMessagesOptions,
+): Promise<AsyncSqliteResult> {
+  if (options.idPairs.length === 0) {
+    return {
+      ok: true,
+      backend: "in-process-blocking",
+      error: null,
+      elapsedMs: 0,
+    };
+  }
+
+  const sql = buildForkCopyScript(options);
+  return runAsyncSqlite(sql, {
+    ...(options.forceInProcess
+      ? { forceBackend: "in-process-blocking" as const }
+      : {}),
+  });
+}

package/src/memory/graph/__tests__/handle-remember-v2.test.ts

@@ -227,3 +227,95 @@ describe("handleRemember — memory.v2.enabled off (v1 PKB path)", () => {
     }
   });
 });
+
+describe("handleRemember — batch (array) content", () => {
+  test("v2: writes every fact from an array in a single call", () => {
+    const result = handleRemember(
+      { content: ["fact one", "fact two", "fact three"] },
+      "conv-batch-1",
+      "default",
+      CONFIG,
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain("3");
+
+    const memoryDir = join(tmpWorkspace, "memory");
+    const buffer = readFileSync(join(memoryDir, "buffer.md"), "utf-8");
+    expect(buffer).toContain("fact one");
+    expect(buffer).toContain("fact two");
+    expect(buffer).toContain("fact three");
+    // Three independent timestamped bullets from the one call.
+    expect(buffer.match(/^- /gm)?.length).toBe(3);
+
+    const archive = readFileSync(
+      join(memoryDir, "archive", todaysArchiveBasename()),
+      "utf-8",
+    );
+    expect(archive).toContain("fact one");
+    expect(archive).toContain("fact three");
+  });
+
+  test("v1: a batched call still enqueues exactly two re-index jobs (per file, not per fact)", () => {
+    const result = handleRemember(
+      { content: ["alpha", "beta", "gamma"] },
+      "conv-batch-2",
+      "default",
+      CONFIG_V2_OFF,
+    );
+
+    expect(result.success).toBe(true);
+
+    const pkbDir = join(tmpWorkspace, "pkb");
+    const buffer = readFileSync(join(pkbDir, "buffer.md"), "utf-8");
+    expect(buffer).toContain("alpha");
+    expect(buffer).toContain("beta");
+    expect(buffer).toContain("gamma");
+    expect(buffer.match(/^- /gm)?.length).toBe(3);
+
+    // One enqueue per written file (buffer + archive), regardless of fact count.
+    expect(enqueueCalls).toHaveLength(2);
+  });
+
+  test("drops blank entries and rejects an all-empty array", () => {
+    const ok = handleRemember(
+      { content: ["   ", "kept fact", ""] },
+      "conv-batch-3",
+      "default",
+      CONFIG,
+    );
+    expect(ok.success).toBe(true);
+    const buffer = readFileSync(
+      join(tmpWorkspace, "memory", "buffer.md"),
+      "utf-8",
+    );
+    expect(buffer).toContain("kept fact");
+    expect(buffer.match(/^- /gm)?.length).toBe(1);
+
+    const empty = handleRemember(
+      { content: ["   ", ""] },
+      "conv-batch-4",
+      "default",
+      CONFIG,
+    );
+    expect(empty.success).toBe(false);
+    expect(empty.message).toContain("content is required");
+  });
+
+  test("single-string content still records exactly one fact", () => {
+    const result = handleRemember(
+      { content: "lone fact" },
+      "conv-batch-5",
+      "default",
+      CONFIG,
+    );
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("Saved to knowledge base.");
+    const buffer = readFileSync(
+      join(tmpWorkspace, "memory", "buffer.md"),
+      "utf-8",
+    );
+    expect(buffer).toContain("lone fact");
+    expect(buffer.match(/^- /gm)?.length).toBe(1);
+  });
+});

package/src/memory/graph/bootstrap.test.ts

@@ -1,6 +1,7 @@
 import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
 
 import { setMemoryCheckpoint } from "../checkpoints.js";
+import { getMemoryDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import { rawAll, rawGet, rawRun, resetTestTables } from "../raw-query.js";
 import { migrateToolCreatedItems } from "./bootstrap.js";
@@ -15,13 +16,15 @@ const MIGRATE_ITEMS_CHECKPOINT = "graph_bootstrap:migrated_tool_items";
 // Setup
 // ---------------------------------------------------------------------------
 
-beforeAll(() => {
-  initializeDb();
+beforeAll(async () => {
+  await initializeDb();
 });
 
 beforeEach(() => {
   // Clear graph nodes and checkpoints between tests so each test starts clean.
-  resetTestTables("memory_graph_nodes", "memory_checkpoints", "memory_jobs");
+  // memory_jobs lives in the dedicated memory connection; the rest in main.
+  resetTestTables("memory_graph_nodes", "memory_checkpoints");
+  getMemoryDb()!.run("DELETE FROM memory_jobs");
 });
 
 // ---------------------------------------------------------------------------

package/src/memory/graph/retriever.test.ts

@@ -124,18 +124,18 @@ function makeCapabilityNode(content: string, capId: string): NewNode {
 }
 
 describe("loadContextMemory — query/sparse vector surfacing", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
-  beforeEach(() => {
+  beforeEach(async () => {
     embedShouldThrow = false;
     embedVector = [0.1, 0.2, 0.3];
     embedCallCount = 0;
     embedRouter = null;
     searchRouter = null;
     resetDbForTesting();
-    initializeDb();
+    await initializeDb();
   });
 
   test("returns the dense queryVector when embedding succeeds", async () => {
@@ -180,18 +180,18 @@ describe("loadContextMemory — query/sparse vector surfacing", () => {
 });
 
 describe("retrieveForTurn — query/sparse vector surfacing", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
-  beforeEach(() => {
+  beforeEach(async () => {
     embedShouldThrow = false;
     embedVector = [0.1, 0.2, 0.3];
     embedCallCount = 0;
     embedRouter = null;
     searchRouter = null;
     resetDbForTesting();
-    initializeDb();
+    await initializeDb();
   });
 
   test("returns the dense queryVector when embedding succeeds", async () => {
@@ -309,8 +309,8 @@ describe("retrieveForTurn — topic-pivot recovery", () => {
     };
   }
 
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
   beforeEach(() => {
@@ -458,8 +458,8 @@ describe("loadContextMemory — dual-query capability ranking", () => {
     return [];
   }
 
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
   beforeEach(() => {

package/src/memory/graph/store.test.ts

@@ -61,8 +61,8 @@ function makeNewNode(overrides: Partial<NewNode> = {}): NewNode {
   };
 }
 
-beforeAll(() => {
-  initializeDb();
+beforeAll(async () => {
+  await initializeDb();
 });
 
 beforeEach(() => {
@@ -259,12 +259,8 @@ describe("queryNodes", () => {
   });
 
   test("filters by eventDateAfter", () => {
-    createNode(
-      makeNewNode({ content: "Old.", eventDate: 1700000000000 }),
-    );
-    createNode(
-      makeNewNode({ content: "Recent.", eventDate: 1710000000000 }),
-    );
+    createNode(makeNewNode({ content: "Old.", eventDate: 1700000000000 }));
+    createNode(makeNewNode({ content: "Recent.", eventDate: 1710000000000 }));
     createNode(makeNewNode({ content: "None.", eventDate: null }));
 
     const results = queryNodes({ eventDateAfter: 1705000000000 });
@@ -273,12 +269,8 @@ describe("queryNodes", () => {
   });
 
   test("filters by eventDateBefore", () => {
-    createNode(
-      makeNewNode({ content: "Old.", eventDate: 1700000000000 }),
-    );
-    createNode(
-      makeNewNode({ content: "Recent.", eventDate: 1710000000000 }),
-    );
+    createNode(makeNewNode({ content: "Old.", eventDate: 1700000000000 }));
+    createNode(makeNewNode({ content: "Recent.", eventDate: 1710000000000 }));
     createNode(makeNewNode({ content: "None.", eventDate: null }));
 
     const results = queryNodes({ eventDateBefore: 1705000000000 });
@@ -287,15 +279,9 @@ describe("queryNodes", () => {
   });
 
   test("combines eventDateAfter and eventDateBefore for range query", () => {
-    createNode(
-      makeNewNode({ content: "Before.", eventDate: 1690000000000 }),
-    );
-    createNode(
-      makeNewNode({ content: "In range.", eventDate: 1700000000000 }),
-    );
-    createNode(
-      makeNewNode({ content: "After.", eventDate: 1720000000000 }),
-    );
+    createNode(makeNewNode({ content: "Before.", eventDate: 1690000000000 }));
+    createNode(makeNewNode({ content: "In range.", eventDate: 1700000000000 }));
+    createNode(makeNewNode({ content: "After.", eventDate: 1720000000000 }));
 
     const results = queryNodes({
       eventDateAfter: 1695000000000,
@@ -687,7 +673,9 @@ describe("supersedeNode", () => {
 
   test("inherits eventDate from old node when new node has null eventDate", () => {
     const eventDate = 1712534400000; // April 8 2024
-    const old = createNode(makeNewNode({ content: "Dentist April 8.", eventDate }));
+    const old = createNode(
+      makeNewNode({ content: "Dentist April 8.", eventDate }),
+    );
     const newNodeInput = makeNewNode({
       content: "Dentist appointment rescheduled.",
       eventDate: null,
@@ -699,7 +687,9 @@ describe("supersedeNode", () => {
   });
 
   test("uses new node eventDate when both nodes have eventDate", () => {
-    const old = createNode(makeNewNode({ content: "Flight Tuesday.", eventDate: 1712534400000 }));
+    const old = createNode(
+      makeNewNode({ content: "Flight Tuesday.", eventDate: 1712534400000 }),
+    );
     const newEventDate = 1712620800000;
     const newNodeInput = makeNewNode({
       content: "Flight moved to Thursday.",