@vellumai/assistant 0.8.0 → 0.8.2

package/src/memory/__tests__/memory-retrospective-startup-cleanup.test.ts

@@ -0,0 +1,318 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock state — reset between tests.
+// ---------------------------------------------------------------------------
+
+type ConvRow = {
+  id: string;
+  source: string | null;
+  last_message_at: number | null;
+  fork_parent_conversation_id: string | null;
+  created_at: number;
+};
+type JobRow = {
+  type: string;
+  status: string;
+  payload: string;
+};
+
+let mockConversations: ConvRow[] = [];
+let mockJobs: JobRow[] = [];
+let deletedIds: string[] = [];
+
+mock.module("../db-connection.js", () => ({
+  getDb: () => ({
+    select: (cols?: Record<string, unknown>) => ({
+      from: (_table: { _: { name: string } } | unknown) => ({
+        where: (..._args: unknown[]) => ({
+          all: () => {
+            // Heuristic: tests only construct two query shapes — the jobs
+            // query and the conversations query. Distinguish by the first
+            // requested column shape.
+            const colKeys = cols ? Object.keys(cols) : [];
+            if (colKeys.includes("conversationId")) {
+              return mockJobs
+                .filter(
+                  (j) =>
+                    j.type === "memory_retrospective" &&
+                    (j.status === "pending" || j.status === "running"),
+                )
+                .map((j) => {
+                  let convId: string | null = null;
+                  try {
+                    const parsed = JSON.parse(j.payload) as {
+                      conversationId?: unknown;
+                    };
+                    if (typeof parsed.conversationId === "string") {
+                      convId = parsed.conversationId;
+                    }
+                  } catch {
+                    // Ignore malformed payload
+                  }
+                  return { conversationId: convId };
+                });
+            }
+            // The "all retros" query (used to compute most-recent-per-source
+            // preservation) requests id + forkParentConversationId + createdAt
+            // with only the source + isNotNull(forkParent) predicate.
+            if (
+              colKeys.includes("forkParentConversationId") &&
+              colKeys.includes("createdAt")
+            ) {
+              return mockConversations
+                .filter((c) => c.source === "memory-retrospective")
+                .filter((c) => c.fork_parent_conversation_id !== null)
+                .map((c) => ({
+                  id: c.id,
+                  forkParentConversationId: c.fork_parent_conversation_id,
+                  createdAt: c.created_at,
+                }));
+            }
+            // Otherwise, this is the orphan-candidate query. The production
+            // predicate compares `forkParentConversationId` (the source ID
+            // encoded on the background conversation row) against the set
+            // of source IDs extracted from active jobs.
+            return mockConversations
+              .filter((c) => c.source === "memory-retrospective")
+              .filter(
+                (c) =>
+                  c.last_message_at !== null &&
+                  c.last_message_at < injectedNowMinusOrphanAgeMs,
+              )
+              .filter(
+                (c) =>
+                  c.fork_parent_conversation_id === null ||
+                  !activeJobSourceConvIds.has(c.fork_parent_conversation_id),
+              )
+              .map((c) => ({ id: c.id }));
+          },
+        }),
+      }),
+    }),
+  }),
+}));
+
+let activeJobSourceConvIds = new Set<string>();
+let injectedNowMinusOrphanAgeMs = 0;
+
+mock.module("../conversation-crud.js", () => ({
+  deleteConversation: (id: string) => {
+    deletedIds.push(id);
+    mockConversations = mockConversations.filter((c) => c.id !== id);
+  },
+}));
+
+import { sweepOrphanMemoryRetrospectiveConversations } from "../memory-retrospective-startup-cleanup.js";
+
+const ORPHAN_AGE_MS = 60 * 60 * 1000;
+
+function rebuildActiveJobSet(): void {
+  activeJobSourceConvIds = new Set();
+  for (const j of mockJobs) {
+    if (
+      j.type !== "memory_retrospective" ||
+      (j.status !== "pending" && j.status !== "running")
+    ) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(j.payload) as { conversationId?: unknown };
+      if (typeof parsed.conversationId === "string") {
+        activeJobSourceConvIds.add(parsed.conversationId);
+      }
+    } catch {
+      // ignore
+    }
+  }
+}
+
+describe("sweepOrphanMemoryRetrospectiveConversations", () => {
+  beforeEach(() => {
+    mockConversations = [];
+    mockJobs = [];
+    deletedIds = [];
+    activeJobSourceConvIds = new Set();
+    injectedNowMinusOrphanAgeMs = 0;
+  });
+
+  afterEach(() => {
+    mockConversations = [];
+    mockJobs = [];
+  });
+
+  test("sweeps an old memory-retrospective orphan that has been superseded by a newer retro for the same source", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "old-orphan",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 3 * ORPHAN_AGE_MS,
+      },
+      // Newer successful retro for the same source — this one is preserved.
+      {
+        id: "newer-retro",
+        source: "memory-retrospective",
+        last_message_at: now - 90 * 60 * 1000,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(1);
+    expect(deletedIds).toEqual(["old-orphan"]);
+  });
+
+  test("does NOT sweep recent memory-retrospective conversations", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "fresh-bg",
+        source: "memory-retrospective",
+        last_message_at: now - 60_000,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 60_000,
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+
+  test("does NOT sweep conversations of OTHER sources, even when old", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "auto-analysis-old",
+        source: "auto-analysis",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+  });
+
+  // Regression test for the previously-broken active-job guard. Before the
+  // fix, the predicate compared `conversations.id` (the BACKGROUND-conv id)
+  // to source-conv ids extracted from job payloads — two different identifier
+  // spaces — so the guard never matched and in-flight retros were swept.
+  test("does NOT sweep a background conversation whose SOURCE has an active job (different identifier spaces)", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    // The background conv has its own id, distinct from the source it forks
+    // from. The active job's payload references the SOURCE, not the
+    // background.
+    mockConversations = [
+      {
+        id: "background-conv-id",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-conv-id",
+        created_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    mockJobs = [
+      {
+        type: "memory_retrospective",
+        status: "pending",
+        payload: JSON.stringify({ conversationId: "source-conv-id" }),
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+
+  test("sweeps a superseded background conversation whose source has NO active job, even when another unrelated job is pending", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "background-A",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 3 * ORPHAN_AGE_MS,
+      },
+      {
+        id: "newer-A",
+        source: "memory-retrospective",
+        last_message_at: now - 90 * 60 * 1000,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    // Active job references a DIFFERENT source — neither retro above is
+    // protected by the active-job guard.
+    mockJobs = [
+      {
+        type: "memory_retrospective",
+        status: "pending",
+        payload: JSON.stringify({ conversationId: "source-B" }),
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(1);
+    expect(deletedIds).toEqual(["background-A"]);
+  });
+
+  // Regression test for Devin's concern on PR #30331: the sweep used to
+  // delete every memory-retrospective conversation older than 1h, including
+  // the most-recent successful one per source. That broke
+  // `findMostRecentRetrospectiveFor` on the next run — the next retro had
+  // no dedup context and could re-save facts the prior pass already captured.
+  test("PRESERVES the most-recent retro per source even when older than the orphan cutoff", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "successful-retro",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+
+  test("running across an empty workspace returns swept=0 without errors", () => {
+    const result = sweepOrphanMemoryRetrospectiveConversations();
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+});

package/src/memory/__tests__/memory-retrospective-trigger-check.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+
+import { shouldEnqueueRetrospective } from "../memory-retrospective-trigger-check.js";
+
+const THRESHOLDS = {
+  timeThresholdMs: 30 * 60 * 1000, // 30 min
+  messageThreshold: 10,
+  minCooldownMs: 5 * 60 * 1000, // 5 min
+};
+
+describe("shouldEnqueueRetrospective", () => {
+  test("no state — returns 'interval' regardless of message count", () => {
+    const result = shouldEnqueueRetrospective({
+      state: null,
+      newMessageCount: 0,
+      now: Date.now(),
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+
+  test("cooldown gate — within minCooldownMs, returns null even if other thresholds would trip", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 60_000 }, // 1 min ago
+      newMessageCount: 50, // way over threshold
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBeNull();
+  });
+
+  test("cooldown elapsed + time threshold reached — returns 'interval'", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 31 * 60_000 },
+      newMessageCount: 1,
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+
+  test("cooldown elapsed + time threshold not reached + message threshold met — returns 'message_count'", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 6 * 60_000 }, // past cooldown
+      newMessageCount: 10, // exactly at threshold
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("message_count");
+  });
+
+  test("cooldown elapsed + neither threshold met — returns null", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 6 * 60_000 },
+      newMessageCount: 5, // below threshold
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBeNull();
+  });
+
+  test("time threshold at exact boundary — returns 'interval'", () => {
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 30 * 60_000 },
+      newMessageCount: 1,
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+
+  test("message threshold prefers 'message_count' label when both could fire (interval also at boundary)", () => {
+    // When the interval is also at threshold AND there are also enough
+    // new messages, interval wins because it's evaluated first — the
+    // trigger label is for observability only, the action is the same.
+    const now = Date.now();
+    const result = shouldEnqueueRetrospective({
+      state: { lastProcessedMessageId: "m1", lastRunAt: now - 31 * 60_000 },
+      newMessageCount: 20,
+      now,
+      ...THRESHOLDS,
+    });
+    expect(result).toBe("interval");
+  });
+});

package/src/memory/__tests__/memory-v2-activation-log-store.test.ts

@@ -23,6 +23,7 @@ import { initializeDb } from "../db-init.js";
 import {
   backfillMemoryV2ActivationMessageId,
   getMemoryV2ActivationLogByMessageIds,
+  type MemoryV2ConceptRowRecord,
   recordMemoryV2ActivationLog,
 } from "../memory-v2-activation-log-store.js";
 import { memoryV2ActivationLogs } from "../schema.js";
@@ -66,6 +67,74 @@ describe("memory-v2-activation-log-store", () => {
     expect(result!.config).toEqual(sampleConfig);
   });
 
+  test("round-trip: router-mode log row with zeroed activations and source: 'router'", () => {
+    const conversationId = "conv-router";
+    const messageId = "msg-router";
+
+    const routerConcepts: MemoryV2ConceptRowRecord[] = [
+      {
+        slug: "concept-router-a",
+        finalActivation: 0,
+        ownActivation: 0,
+        priorActivation: 0,
+        simUser: 0,
+        simAssistant: 0,
+        simNow: 0,
+        simUserRerankBoost: 0,
+        simAssistantRerankBoost: 0,
+        inRerankPool: false,
+        spreadContribution: 0,
+        source: "router",
+        status: "injected",
+      },
+      {
+        slug: "concept-router-b",
+        finalActivation: 0,
+        ownActivation: 0,
+        priorActivation: 0,
+        simUser: 0,
+        simAssistant: 0,
+        simNow: 0,
+        simUserRerankBoost: 0,
+        simAssistantRerankBoost: 0,
+        inRerankPool: false,
+        spreadContribution: 0,
+        source: "router",
+        status: "not_injected",
+      },
+    ];
+
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 7,
+      mode: "router",
+      concepts: routerConcepts,
+      config: sampleConfig,
+    });
+
+    backfillMemoryV2ActivationMessageId(conversationId, messageId);
+
+    const result = getMemoryV2ActivationLogByMessageIds([messageId]);
+    expect(result).not.toBeNull();
+    expect(result!.conversationId).toBe(conversationId);
+    expect(result!.turn).toBe(7);
+    expect(result!.mode).toBe("router");
+    expect(result!.concepts).toEqual(routerConcepts);
+    expect(result!.config).toEqual(sampleConfig);
+    for (const concept of result!.concepts) {
+      expect(concept.source).toBe("router");
+      expect(concept.finalActivation).toBe(0);
+      expect(concept.ownActivation).toBe(0);
+      expect(concept.priorActivation).toBe(0);
+      expect(concept.simUser).toBe(0);
+      expect(concept.simAssistant).toBe(0);
+      expect(concept.simNow).toBe(0);
+      expect(concept.simUserRerankBoost).toBe(0);
+      expect(concept.simAssistantRerankBoost).toBe(0);
+      expect(concept.spreadContribution).toBe(0);
+    }
+  });
+
   test("returns null for empty messageIds array", () => {
     const result = getMemoryV2ActivationLogByMessageIds([]);
     expect(result).toBeNull();

package/src/memory/__tests__/memory-v2-concept-frequency.test.ts

@@ -117,6 +117,7 @@ describe("memory-v2-concept-frequency", () => {
       in_context: 1,
       not_injected: 0,
       page_missing: 0,
+      corrupt: 0,
     });
     expect(bySlug.get("alice")!.totalEvaluations).toBe(3);
     expect(bySlug.get("alice")!.onDisk).toBe(true);
@@ -127,6 +128,7 @@ describe("memory-v2-concept-frequency", () => {
       in_context: 0,
       not_injected: 1,
       page_missing: 0,
+      corrupt: 0,
     });
     expect(bySlug.get("bob")!.totalEvaluations).toBe(2);
     expect(bySlug.get("bob")!.onDisk).toBe(true);
@@ -136,6 +138,7 @@ describe("memory-v2-concept-frequency", () => {
       in_context: 0,
       not_injected: 0,
       page_missing: 1,
+      corrupt: 0,
     });
     expect(bySlug.get("charlie")!.onDisk).toBe(false);
     expect(bySlug.get("charlie")!.lastInjectedAt).toBeNull();

package/src/memory/__tests__/message-content.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+
+import { stringifyMessageContent } from "../message-content.js";
+
+describe("stringifyMessageContent", () => {
+  test("returns trimmed raw text for legacy plain-string rows", () => {
+    expect(stringifyMessageContent("  hello world  ")).toBe("hello world");
+  });
+
+  test("returns trimmed inner string when JSON parses to a string", () => {
+    expect(stringifyMessageContent(JSON.stringify("  inner  "))).toBe("inner");
+  });
+
+  test("concatenates text blocks from a ContentBlock[] payload", () => {
+    const raw = JSON.stringify([
+      { type: "text", text: "alpha" },
+      { type: "tool_use", id: "x", name: "noop", input: {} },
+      { type: "text", text: "beta" },
+    ]);
+    expect(stringifyMessageContent(raw)).toBe("alpha\nbeta");
+  });
+
+  test("falls back to raw trimmed text when JSON parses to a non-array object", () => {
+    const raw = '  {"type":"text","text":"hi"}  ';
+    expect(stringifyMessageContent(raw)).toBe('{"type":"text","text":"hi"}');
+  });
+
+  test("falls back to raw trimmed text when JSON parses to a number", () => {
+    expect(stringifyMessageContent("  42  ")).toBe("42");
+  });
+
+  test("returns trimmed raw text when JSON parsing fails", () => {
+    expect(stringifyMessageContent("  not json  ")).toBe("not json");
+  });
+});