@vellumai/assistant 0.8.5 → 0.8.6

package/src/memory/db-connection.ts

@@ -6,12 +6,15 @@ import { Database } from "bun:sqlite";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { ensureDataDir, getDbPath } from "../util/platform.js";
+import {
+  clearStoredDb,
+  getStoredDb,
+  setStoredDb,
+} from "./db-singleton.js";
 import * as schema from "./schema.js";
 
 export type DrizzleDb = ReturnType<typeof drizzle<typeof schema>>;
 
-let db: DrizzleDb | null = null;
-
 function canonicalizePathThroughExistingParent(path: string): string {
   const resolvedPath = resolve(path);
   const pendingSegments: string[] = [];
@@ -71,18 +74,20 @@ function assertTestDbIsIsolated(): void {
 }
 
 export function getDb(): DrizzleDb {
-  if (!db) {
-    assertTestDbIsIsolated();
-    ensureDataDir();
-    const sqlite = new Database(getDbPath());
-    sqlite.exec("PRAGMA journal_mode=WAL");
-    sqlite.exec("PRAGMA synchronous=FULL");
-    sqlite.exec("PRAGMA busy_timeout=5000");
-    sqlite.exec("PRAGMA foreign_keys = ON");
-    sqlite.exec("PRAGMA cache_size=-256000");
-    sqlite.exec("PRAGMA temp_store=MEMORY");
-    db = drizzle(sqlite, { schema });
-  }
+  const existing = getStoredDb<DrizzleDb>();
+  if (existing) return existing;
+
+  assertTestDbIsIsolated();
+  ensureDataDir();
+  const sqlite = new Database(getDbPath());
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA synchronous=FULL");
+  sqlite.exec("PRAGMA busy_timeout=5000");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  sqlite.exec("PRAGMA cache_size=-256000");
+  sqlite.exec("PRAGMA temp_store=MEMORY");
+  const db = drizzle(sqlite, { schema });
+  setStoredDb(db, () => sqlite.close());
   return db;
 }
 
@@ -107,10 +112,15 @@ export function getSqliteFrom(drizzleDb: DrizzleDb): Database {
   return (drizzleDb as unknown as { $client: Database }).$client;
 }
 
-/** Reset the db singleton. Used by tests to ensure isolation between test files. */
+/**
+ * Reset the db singleton. Used by production callers that need to close
+ * the live connection so the file can be replaced (post-migration,
+ * post-restore, post-vbundle-import) and on graceful shutdown.
+ *
+ * Tests should use `resetDbForTesting()` from
+ * `__tests__/db-test-helpers.ts` instead so they don't depend on this
+ * module's heavy import chain (`drizzle-orm/bun-sqlite`).
+ */
 export function resetDb(): void {
-  if (db) {
-    getSqliteFrom(db).close();
-    db = null;
-  }
+  clearStoredDb();
 }

package/src/memory/db-init.ts

@@ -96,6 +96,7 @@ import {
   migrateDropMemoryItemsTables,
   migrateDropMemorySegmentFts,
   migrateDropOrphanedMediaTables,
+  migrateDropProviderConnectionStatus,
   migrateDropRemindersTable,
   migrateDropSetupSkillIdColumn,
   migrateDropSimplifiedMemory,
@@ -133,6 +134,7 @@ import {
   migrateMemoryV3AutoEdges,
   migrateMemoryV3Coactivation,
   migrateMessageBookmarks,
+  migrateMessagesClientMessageId,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
   migrateNormalizePhoneIdentities,
@@ -462,6 +464,8 @@ export function initializeDb(): void {
     migrateMemoryV3Coactivation,
     migrateMemoryV3AutoEdges,
     migrateLlmRequestLogCallSite,
+    migrateDropProviderConnectionStatus,
+    migrateMessagesClientMessageId,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/db-singleton.ts

@@ -0,0 +1,77 @@
+/**
+ * Holds the assistant DB connection singleton and its close callback.
+ *
+ * Lives in its own module (rather than alongside the resolver in
+ * `db-connection.ts`) so test code can reset the singleton 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
+ * 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
+ * `__tests__/db-test-helpers.ts` for the test-side mirror; the slot
+ * shape MUST stay in sync between the two.
+ *
+ * The stored value is typed as `unknown` so this file never has to import
+ * Drizzle types. Callers in `db-connection.ts` narrow via the type
+ * parameter on `getStoredDb<DrizzleDb>()`.
+ *
+ * Consumers:
+ *   - `db-connection.ts` (opens/owns the connection)
+ *   - production callers that need to close the active connection
+ *     (migration routes, vbundle import, backup/restore, daemon shutdown)
+ *   - `__tests__/db-test-helpers.ts` (per-test reset, via globalThis)
+ */
+
+type DbSlot = {
+  db: unknown;
+  closer: (() => void) | null;
+};
+
+type VellumAssistantNamespace = {
+  dbSingleton?: DbSlot;
+};
+
+function slot(): DbSlot {
+  const g = globalThis as { vellumAssistant?: VellumAssistantNamespace };
+  const ns = (g.vellumAssistant ??= {});
+  return (ns.dbSingleton ??= { db: null, closer: null });
+}
+
+/** Read the current singleton, narrowed to `T`. `null` means not yet opened. */
+export function getStoredDb<T>(): T | null {
+  return slot().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
+ * 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();
+  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.
+ */
+export function clearStoredDb(): void {
+  const s = slot();
+  if (s.closer) {
+    try {
+      s.closer();
+    } catch {
+      /* best-effort close */
+    }
+  }
+  s.db = null;
+  s.closer = null;
+}

package/src/memory/delivery-channels.ts

@@ -10,6 +10,36 @@ import { eq } from "drizzle-orm";
 import { getDb } from "./db-connection.js";
 import { channelInboundEvents } from "./schema.js";
 
+const SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES =
+  "slackDmLiveDeliveredTextResponseIndexes";
+
+function parseRawPayload(
+  rawPayload: string | null,
+): Record<string, unknown> | undefined {
+  if (!rawPayload) return undefined;
+  try {
+    const parsed = JSON.parse(rawPayload) as unknown;
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      return undefined;
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizePositiveIntegerIndexes(value: unknown): number[] {
+  if (!Array.isArray(value)) return [];
+  const indexes = value.filter(
+    (item): item is number => Number.isSafeInteger(item) && item > 0,
+  );
+  return [...new Set(indexes)].sort((a, b) => a - b);
+}
+
 // ── Pending verification reply helpers ───────────────────────────────
 //
 // When a guardian verification succeeds but the confirmation reply fails
@@ -100,6 +130,58 @@ export function updateDeliveredSegmentCount(
     .run();
 }
 
+export function getSlackDmLiveDeliveredTextResponseIndexes(
+  eventId: string,
+): number[] {
+  const db = getDb();
+  const row = db
+    .select({ rawPayload: channelInboundEvents.rawPayload })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+  const payload = parseRawPayload(row?.rawPayload ?? null);
+  if (!payload) return [];
+  return normalizePositiveIntegerIndexes(
+    payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
+  );
+}
+
+export function addSlackDmLiveDeliveredTextResponseIndex(
+  eventId: string,
+  responseIndex: number,
+): void {
+  if (!Number.isSafeInteger(responseIndex) || responseIndex <= 0) return;
+
+  const db = getDb();
+  db.transaction((tx) => {
+    const row = tx
+      .select({ rawPayload: channelInboundEvents.rawPayload })
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, eventId))
+      .get();
+    if (!row?.rawPayload) return;
+
+    const payload = parseRawPayload(row.rawPayload);
+    if (!payload) return;
+    const indexes = normalizePositiveIntegerIndexes(
+      payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
+    );
+    if (!indexes.includes(responseIndex)) indexes.push(responseIndex);
+    indexes.sort((a, b) => a - b);
+
+    tx.update(channelInboundEvents)
+      .set({
+        rawPayload: JSON.stringify({
+          ...payload,
+          [SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES]: indexes,
+        }),
+        updatedAt: Date.now(),
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  });
+}
+
 // ── Deliver-once guard for terminal reply idempotency ────────────────
 //
 // When both the main poll (processChannelMessageWithApprovals) and the

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -28,6 +28,7 @@ import {
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
+import { createMockLoggerModule } from "../../../__tests__/helpers/mock-logger.js";
 import type { AssistantConfig } from "../../../config/types.js";
 import type { Message } from "../../../providers/types.js";
 
@@ -35,10 +36,7 @@ import type { Message } from "../../../providers/types.js";
 // Module mocks (must precede the dynamic imports below)
 // ---------------------------------------------------------------------------
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
+mock.module("../../../util/logger.js", () => createMockLoggerModule());
 
 // Stub the v1 retriever so we don't reach Qdrant. Both modes return zero
 // nodes — the v1 injection branch becomes a no-op, isolating the assertion

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

@@ -71,9 +71,9 @@ mock.module("../../providers/provider-send-message.js", () => ({
   extractToolUse: () => null,
 }));
 
+import { resetDbForTesting } from "../../__tests__/db-test-helpers.js";
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { resetDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import { resetTestTables } from "../raw-query.js";
 import { InContextTracker } from "./injection.js";
@@ -134,7 +134,7 @@ describe("loadContextMemory — query/sparse vector surfacing", () => {
     embedCallCount = 0;
     embedRouter = null;
     searchRouter = null;
-    resetDb();
+    resetDbForTesting();
     initializeDb();
   });
 
@@ -190,7 +190,7 @@ describe("retrieveForTurn — query/sparse vector surfacing", () => {
     embedCallCount = 0;
     embedRouter = null;
     searchRouter = null;
-    resetDb();
+    resetDbForTesting();
     initializeDb();
   });
 

package/src/memory/job-handlers/embedding.test.ts

@@ -40,9 +40,10 @@ mock.module("../job-utils.js", () => ({
   },
 }));
 
+import { resetDbForTesting } from "../../__tests__/db-test-helpers.js";
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { getDb, resetDb } from "../db-connection.js";
+import { getDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import type { MemoryJob } from "../jobs-store.js";
 import { mediaAssets } from "../schema.js";
@@ -66,7 +67,7 @@ describe("embedMediaJob", () => {
 
   beforeEach(() => {
     embedAndUpsertCalls.length = 0;
-    resetDb();
+    resetDbForTesting();
     initializeDb();
   });
 

package/src/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -142,7 +142,10 @@ afterAll(() => {
 // Imports are deferred to after the env var is set so any internal use of
 // `getWorkspaceDir()` resolves to the tmpdir.
 const { DEFAULT_CONFIG } = await import("../../../config/defaults.js");
-const { getDb, resetDb } = await import("../../db-connection.js");
+const { getDb } = await import("../../db-connection.js");
+const { resetDbForTesting } = await import(
+  "../../../__tests__/db-test-helpers.js"
+);
 const { initializeDb } = await import("../../db-init.js");
 const { memoryEmbeddings, memoryJobs } = await import("../../schema.js");
 const { claimMemoryJobs } = await import("../../jobs-store.js");
@@ -183,7 +186,7 @@ function makeJob(payload: Record<string, unknown>): MemoryJob {
 }
 
 beforeEach(() => {
-  resetDb();
+  resetDbForTesting();
   initializeDb();
   embedWithBackendCalls.length = 0;
   upsertCalls.length = 0;

package/src/memory/jobs-worker.ts

@@ -65,6 +65,7 @@ import {
   enqueuePruneOldTraceEventsJob,
   failMemoryJob,
   failStalledJobs,
+  hasActiveJobOfType,
   type MemoryJob,
   type MemoryJobType,
   resetRunningJobsToPending,
@@ -791,8 +792,18 @@ export function maybeEnqueueGraphMaintenanceJobs(
   // Size-based trigger: when the shared buffer crosses the configured line
   // count, drain it now rather than waiting out the interval. Retargets to the
   // same consolidator the interval branch above selected.
+  //
+  // The size branch is checkpoint-blind by design (it must fire before the
+  // interval elapses), so it dedupes against an already-active consolidate job
+  // instead — otherwise it would re-enqueue on every worker tick while the
+  // buffer stays over threshold, flooding the queue with redundant LLM work.
   const maxLines = config.memory.v2.consolidation_max_buffer_lines;
-  if (v2Active && !enqueuedConsolidate && maxLines !== null) {
+  if (
+    v2Active &&
+    !enqueuedConsolidate &&
+    maxLines !== null &&
+    !hasActiveJobOfType(consolidateEntry.jobType)
+  ) {
     const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
     if (countBufferLines(bufferPath) >= maxLines) {
       enqueueMemoryJob(consolidateEntry.jobType, {});

package/src/memory/llm-request-log-source-clickhouse.ts

@@ -209,6 +209,86 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     return rows.map((r) => this.toLogRow(r));
   }
 
+  async getCompactionLogsBetween(
+    conversationId: string,
+    afterCreatedAt: number | null,
+    beforeCreatedAt: number,
+  ): Promise<LogRow[]> {
+    const aid = await this.assistantId();
+    // `call_site` is bound as a literal via type-bound parameter (not
+    // string interpolation) for parity with the rest of this class —
+    // even though "compactionAgent" is a hard-coded identifier today,
+    // future call sites should plug into the same parameter slot
+    // without re-templating the query string.
+    //
+    // The `afterCreatedAt` lower bound is appended dynamically because
+    // type-bound parameter slots that are referenced in the SQL but
+    // unbound at exec time return a server error — so we only template
+    // the predicate in when the caller actually has a floor to enforce.
+    const params: Record<string, string> = {
+      assistant_id: aid,
+      conversation_id: conversationId,
+      call_site: "compactionAgent",
+      before_created_at: String(beforeCreatedAt),
+    };
+    let afterPredicate = "";
+    if (afterCreatedAt !== null) {
+      params.after_created_at = String(afterCreatedAt);
+      afterPredicate =
+        " AND created_at > fromUnixTimestamp64Milli({after_created_at:Int64})";
+    }
+    const sql = `SELECT
+        id,
+        conversation_id,
+        message_id,
+        provider,
+        request_payload,
+        response_payload,
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason,
+        call_site
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND conversation_id = {conversation_id:String}
+        AND call_site = {call_site:String}
+        AND created_at < fromUnixTimestamp64Milli({before_created_at:Int64})${afterPredicate}
+      ORDER BY created_at ASC, id ASC
+      LIMIT 1 BY id
+      FORMAT JSONEachRow`;
+    const rows = await this.exec(sql, params);
+    return rows.map((r) => this.toLogRow(r));
+  }
+
+  async getPreviousNonCompactionCallCreatedAt(
+    conversationId: string,
+    beforeCreatedAt: number,
+  ): Promise<number | null> {
+    const aid = await this.assistantId();
+    // "Non-compactionAgent" includes empty-string `call_site`, which is
+    // what the CH mirror writes for pre-migration-264 rows whose SQLite
+    // value was NULL (CH columns are `DEFAULT ''`, not Nullable — see
+    // `toLogRow`). The local store treats NULL `callSite` the same way,
+    // so the predicate stays in sync.
+    const sql = `SELECT
+        toUnixTimestamp64Milli(created_at) AS created_at
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND conversation_id = {conversation_id:String}
+        AND created_at < fromUnixTimestamp64Milli({before_created_at:Int64})
+        AND call_site != {call_site:String}
+      ORDER BY created_at DESC, id DESC
+      LIMIT 1
+      FORMAT JSONEachRow`;
+    const rows = await this.exec(sql, {
+      assistant_id: aid,
+      conversation_id: conversationId,
+      call_site: "compactionAgent",
+      before_created_at: String(beforeCreatedAt),
+    });
+    const value = rows[0]?.created_at;
+    return value === undefined ? null : Number(value);
+  }
+
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
     if (ids.length === 0) return [];
     const aid = await this.assistantId();

package/src/memory/llm-request-log-source-local.ts

@@ -10,6 +10,8 @@
  */
 import type { LlmRequestLogSource } from "./llm-request-log-source.js";
 import {
+  getCompactionLogsBetween,
+  getPreviousNonCompactionCallCreatedAt,
   getRequestLogById,
   getRequestLogsByConversationId,
   getRequestLogsByMessageId,
@@ -30,4 +32,26 @@ export class LocalLlmRequestLogSource implements LlmRequestLogSource {
   ): Promise<LogRow[]> {
     return getRequestLogsByConversationId(conversationId);
   }
+
+  async getCompactionLogsBetween(
+    conversationId: string,
+    afterCreatedAt: number | null,
+    beforeCreatedAt: number,
+  ): Promise<LogRow[]> {
+    return getCompactionLogsBetween(
+      conversationId,
+      afterCreatedAt,
+      beforeCreatedAt,
+    );
+  }
+
+  async getPreviousNonCompactionCallCreatedAt(
+    conversationId: string,
+    beforeCreatedAt: number,
+  ): Promise<number | null> {
+    return getPreviousNonCompactionCallCreatedAt(
+      conversationId,
+      beforeCreatedAt,
+    );
+  }
 }

package/src/memory/llm-request-log-source.ts

@@ -38,6 +38,37 @@ export interface LlmRequestLogSource {
    * and orphaned logs are all included because they share conversation_id.
    */
   getRequestLogsByConversationId(conversationId: string): Promise<LogRow[]>;
+
+  /**
+   * Fetch every `callSite = "compactionAgent"` log row in the conversation
+   * whose `createdAt` falls in the **open window**
+   * `(afterCreatedAt, beforeCreatedAt)`, ordered chronologically.
+   *
+   * Drives the Inspector's Compaction tab. The route handler resolves
+   * both bounds: the selected LLM call's `createdAt` (ceiling) and the
+   * previous non-`compactionAgent` call's `createdAt` (floor) — passing
+   * `null` for the floor when the selected call is the first real call
+   * in the conversation. See `getCompactionLogsBetween` and
+   * `getPreviousNonCompactionCallCreatedAt` in `llm-request-log-store.ts`
+   * for the full bound semantics.
+   */
+  getCompactionLogsBetween(
+    conversationId: string,
+    afterCreatedAt: number | null,
+    beforeCreatedAt: number,
+  ): Promise<LogRow[]>;
+
+  /**
+   * Find the `createdAt` of the most recent non-`compactionAgent` LLM
+   * call in the conversation strictly before `beforeCreatedAt`, or
+   * `null` when no such call exists. Pairs with
+   * `getCompactionLogsBetween` to bound the compaction trail to the
+   * window between the prior real call and the selected call.
+   */
+  getPreviousNonCompactionCallCreatedAt(
+    conversationId: string,
+    beforeCreatedAt: number,
+  ): Promise<number | null>;
 }
 
 /**