@vellumai/assistant 0.8.2 → 0.8.4

package/src/memory/__tests__/conversation-queries.test.ts

@@ -14,7 +14,9 @@ import {
   buildExcerpt,
   buildRecallEvidenceExcerpt,
   countConversations,
+  getMessageRoleStatsByConversation,
   listConversations,
+  listConversationsBySource,
 } from "../conversation-queries.js";
 import { getDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
@@ -261,3 +263,221 @@ describe("listConversations", () => {
     expect(fgList).toHaveLength(0);
   });
 });
+
+describe("listConversationsBySource", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns only conversations whose source matches exactly", () => {
+    createConversation({
+      title: "consol-1",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({
+      title: "consol-2",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({ title: "heartbeat-1", source: "heartbeat" });
+    createConversation({ title: "user-1", source: "user" });
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.title).sort()).toEqual([
+      "consol-1",
+      "consol-2",
+    ]);
+  });
+
+  test("orders by createdAt descending", () => {
+    const a = createConversation({
+      title: "a",
+      source: "memory_v2_consolidation",
+    });
+    const b = createConversation({
+      title: "b",
+      source: "memory_v2_consolidation",
+    });
+    const c = createConversation({
+      title: "c",
+      source: "memory_v2_consolidation",
+    });
+    // Force distinct createdAt regardless of ms-clock granularity.
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 1000, a.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 3000, b.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 2000, c.id);
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results.map((r) => r.id)).toEqual([b.id, c.id, a.id]);
+  });
+
+  test("honors the limit parameter", () => {
+    for (let i = 0; i < 5; i++) {
+      createConversation({
+        title: `consol-${i}`,
+        source: "memory_v2_consolidation",
+      });
+    }
+
+    const results = listConversationsBySource("memory_v2_consolidation", 3);
+
+    expect(results).toHaveLength(3);
+  });
+
+  test("includes archived rows by default", () => {
+    const conv = createConversation({
+      title: "archived",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      conv.id,
+    );
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.archivedAt).not.toBeNull();
+  });
+
+  test("excludes archived rows when includeArchived is false", () => {
+    const archived = createConversation({
+      title: "archived",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({ title: "live", source: "memory_v2_consolidation" });
+    rawRun(
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      archived.id,
+    );
+
+    const results = listConversationsBySource("memory_v2_consolidation", 20, {
+      includeArchived: false,
+    });
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.title).toBe("live");
+  });
+
+  test("does not apply the subagent-exclusion that listConversations does", () => {
+    // The defensive `source != 'subagent'` carve-out in listConversations is
+    // a foreground/background bucketing concern. A caller asking for the
+    // exact `subagent` source via this query gets exactly that.
+    createConversation({ title: "sub-1", source: "subagent" });
+
+    const results = listConversationsBySource("subagent");
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.title).toBe("sub-1");
+  });
+});
+
+describe("getMessageRoleStatsByConversation", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  function insertMessage(
+    conversationId: string,
+    role: string,
+    createdAt: number,
+  ): void {
+    rawRun(
+      "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
+      `msg-${conversationId}-${role}-${createdAt}`,
+      conversationId,
+      role,
+      "x",
+      createdAt,
+    );
+  }
+
+  test("returns empty map for empty input", () => {
+    const result = getMessageRoleStatsByConversation([]);
+    expect(result.size).toBe(0);
+  });
+
+  test("returns empty map when conversations exist but no matching role", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(0);
+  });
+
+  test("counts assistant messages and returns max createdAt", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "assistant", 1500);
+    insertMessage(a.id, "assistant", 2500);
+    insertMessage(a.id, "assistant", 2000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(1);
+    expect(result.get(a.id)).toEqual({ count: 3, lastAt: 2500 });
+  });
+
+  test("does not count messages from other roles", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "user", 2000);
+    insertMessage(a.id, "system", 1500);
+    insertMessage(a.id, "assistant", 3000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.get(a.id)).toEqual({ count: 1, lastAt: 3000 });
+  });
+
+  test("scopes to the supplied conversation ids", () => {
+    const a = createConversation("a");
+    const b = createConversation("b");
+    insertMessage(a.id, "assistant", 1000);
+    insertMessage(b.id, "assistant", 2000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(1);
+    expect(result.has(a.id)).toBe(true);
+    expect(result.has(b.id)).toBe(false);
+  });
+
+  test("aggregates per-conversation across many ids in a single query", () => {
+    const a = createConversation("a");
+    const b = createConversation("b");
+    const c = createConversation("c");
+    insertMessage(a.id, "assistant", 1000);
+    insertMessage(a.id, "assistant", 1500);
+    insertMessage(b.id, "assistant", 2000);
+    // c has no assistant messages → absent from the result.
+
+    const result = getMessageRoleStatsByConversation(
+      [a.id, b.id, c.id],
+      "assistant",
+    );
+
+    expect(result.size).toBe(2);
+    expect(result.get(a.id)).toEqual({ count: 2, lastAt: 1500 });
+    expect(result.get(b.id)).toEqual({ count: 1, lastAt: 2000 });
+    expect(result.has(c.id)).toBe(false);
+  });
+
+  test("role parameter selects the counted role (defaults to assistant)", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "user", 2000);
+    insertMessage(a.id, "assistant", 1500);
+
+    const assistants = getMessageRoleStatsByConversation([a.id]);
+    expect(assistants.get(a.id)).toEqual({ count: 1, lastAt: 1500 });
+
+    const users = getMessageRoleStatsByConversation([a.id], "user");
+    expect(users.get(a.id)).toEqual({ count: 2, lastAt: 2000 });
+  });
+});

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -19,7 +19,7 @@
  * Tests use a temp workspace pinned via `VELLUM_WORKSPACE_DIR` so the DB
  * lives under `tmpdir()` and `~/.vellum/` is never touched.
  */
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -66,7 +66,7 @@ const { initializeDb } = await import("../db-init.js");
 const { resetTestTables } = await import("../raw-query.js");
 const { memoryJobs } = await import("../schema.js");
 const { applyNestedDefaults } = await import("../../config/loader.js");
-const { setMemoryCheckpoint, deleteMemoryCheckpoint } =
+const { getMemoryCheckpoint, setMemoryCheckpoint, deleteMemoryCheckpoint } =
   await import("../checkpoints.js");
 const { maybeEnqueueGraphMaintenanceJobs } = await import("../jobs-worker.js");
 
@@ -75,6 +75,7 @@ const CONSOLIDATE_CHECKPOINT_KEY = "memory_v2_consolidate_last_run";
 function buildConfig(overrides: {
   v2Enabled?: boolean;
   intervalHours?: number;
+  maxBufferLines?: number | null;
 }) {
   const partial = applyNestedDefaults({});
   if (overrides.v2Enabled !== undefined) {
@@ -83,9 +84,26 @@ function buildConfig(overrides: {
   if (overrides.intervalHours !== undefined) {
     partial.memory.v2.consolidation_interval_hours = overrides.intervalHours;
   }
+  if (overrides.maxBufferLines !== undefined) {
+    partial.memory.v2.consolidation_max_buffer_lines = overrides.maxBufferLines;
+  }
   return partial;
 }
 
+function writeBuffer(lineCount: number): void {
+  const memoryDir = join(tmpWorkspace, "memory");
+  mkdirSync(memoryDir, { recursive: true });
+  const entries = Array.from(
+    { length: lineCount },
+    (_, i) => `- [Jan 15, 2:${String(i).padStart(2, "0")} PM] note ${i}`,
+  );
+  writeFileSync(join(memoryDir, "buffer.md"), entries.join("\n") + "\n");
+}
+
+function removeBuffer(): void {
+  rmSync(join(tmpWorkspace, "memory", "buffer.md"), { force: true });
+}
+
 function countPendingJobs(type: string): number {
   return getDb()
     .select()
@@ -216,3 +234,118 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 });
+
+describe("maybeEnqueueGraphMaintenanceJobs — buffer-size trigger", () => {
+  test("default threshold (100 lines) fires once the buffer reaches it", () => {
+    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
+
+    const now = Date.now();
+    // Recent checkpoint so the time-based trigger does not fire.
+    setMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY, String(now - 60_000));
+    writeBuffer(100);
+
+    maybeEnqueueGraphMaintenanceJobs(config, now);
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+  });
+
+  test("explicit null disables the size trigger", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      intervalHours: 1,
+      maxBufferLines: null,
+    });
+
+    const now = Date.now();
+    setMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY, String(now - 60_000));
+    writeBuffer(500);
+
+    maybeEnqueueGraphMaintenanceJobs(config, now);
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+  });
+
+  test("enqueues when buffer reaches the threshold even if interval not elapsed", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      intervalHours: 1,
+      maxBufferLines: 5,
+    });
+
+    const now = Date.now();
+    setMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY, String(now - 60_000));
+    writeBuffer(10);
+
+    maybeEnqueueGraphMaintenanceJobs(config, now);
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    // Checkpoint refreshed so the next tick doesn't immediately re-fire.
+    expect(getMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY)).toBe(String(now));
+  });
+
+  test("does not enqueue when buffer is under the threshold", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      intervalHours: 1,
+      maxBufferLines: 5,
+    });
+
+    const now = Date.now();
+    setMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY, String(now - 60_000));
+    writeBuffer(3);
+
+    maybeEnqueueGraphMaintenanceJobs(config, now);
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+  });
+
+  test("treats missing buffer file as zero lines", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      intervalHours: 1,
+      maxBufferLines: 1,
+    });
+
+    const now = Date.now();
+    setMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY, String(now - 60_000));
+    removeBuffer();
+
+    maybeEnqueueGraphMaintenanceJobs(config, now);
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+  });
+
+  test("does not double-enqueue when both triggers would fire", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      intervalHours: 1,
+      maxBufferLines: 5,
+    });
+
+    const now = Date.now();
+    // Stale checkpoint so time-based fires, AND buffer over threshold.
+    setMemoryCheckpoint(
+      CONSOLIDATE_CHECKPOINT_KEY,
+      String(now - 2 * 60 * 60 * 1000),
+    );
+    writeBuffer(10);
+
+    maybeEnqueueGraphMaintenanceJobs(config, now);
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+  });
+
+  test("size trigger inert when v2 is disabled", () => {
+    const config = buildConfig({
+      v2Enabled: false,
+      intervalHours: 1,
+      maxBufferLines: 1,
+    });
+
+    writeBuffer(100);
+
+    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+  });
+});

package/src/memory/__tests__/memory-retrospective-enqueue.test.ts

@@ -11,26 +11,12 @@ mock.module("../../util/logger.js", () => ({
 // Mock state — reset between tests.
 // ---------------------------------------------------------------------------
 
-let flagEnabled = true;
 let sourceTag: string | null = null;
-let getConfigThrows = false;
 const upsertCalls: Array<{
   payload: { conversationId: string };
   runAfter: number;
 }> = [];
 
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => {
-    if (getConfigThrows) throw new Error("boom");
-    return {};
-  },
-}));
-
-mock.module("../../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
-    flagEnabled,
-}));
-
 mock.module("../conversation-crud.js", () => ({
   getConversationSource: (_id: string) => sourceTag,
 }));
@@ -59,26 +45,11 @@ import {
 
 describe("enqueueMemoryRetrospectiveIfEnabled", () => {
   beforeEach(() => {
-    flagEnabled = true;
     sourceTag = null;
-    getConfigThrows = false;
     upsertCalls.length = 0;
   });
 
-  test("flag off — no upsert for any trigger", () => {
-    flagEnabled = false;
-    for (const trigger of [
-      "interval",
-      "message_count",
-      "compaction",
-      "lifecycle",
-    ] as const) {
-      enqueueMemoryRetrospectiveIfEnabled({ conversationId: "c1", trigger });
-    }
-    expect(upsertCalls).toHaveLength(0);
-  });
-
-  test("flag on, standard source — interval trigger enqueues with runAfter ≈ now", () => {
+  test("standard source — interval trigger enqueues with runAfter ≈ now", () => {
     const before = Date.now();
     enqueueMemoryRetrospectiveIfEnabled({
       conversationId: "c1",
@@ -113,17 +84,6 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     });
     expect(upsertCalls).toHaveLength(0);
   });
-
-  test("getConfig throws — no enqueue, no propagation", () => {
-    getConfigThrows = true;
-    expect(() =>
-      enqueueMemoryRetrospectiveIfEnabled({
-        conversationId: "c1",
-        trigger: "interval",
-      }),
-    ).not.toThrow();
-    expect(upsertCalls).toHaveLength(0);
-  });
 });
 
 describe("isMemoryRetrospectiveConversation", () => {
@@ -149,9 +109,7 @@ describe("isMemoryRetrospectiveConversation", () => {
 
 describe("enqueueMemoryRetrospectiveOnCompaction", () => {
   beforeEach(() => {
-    flagEnabled = true;
     sourceTag = null;
-    getConfigThrows = false;
     upsertCalls.length = 0;
   });
 
@@ -162,16 +120,10 @@ describe("enqueueMemoryRetrospectiveOnCompaction", () => {
     expect(upsertCalls).toHaveLength(0);
   });
 
-  test("guardian trust + flag on — enqueues with compaction debounce", () => {
+  test("guardian trust — enqueues with compaction debounce", () => {
     const before = Date.now();
     enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
     expect(upsertCalls).toHaveLength(1);
     expect(upsertCalls[0]!.runAfter).toBeGreaterThan(before + 100);
   });
-
-  test("guardian trust + flag off — no enqueue", () => {
-    flagEnabled = false;
-    enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
-    expect(upsertCalls).toHaveLength(0);
-  });
 });