@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/plugins/defaults/memory/__tests__/memory-retrospective-accounting.test.ts

@@ -0,0 +1,199 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  createConversation,
+  type MessageRow,
+} from "../../../../persistence/conversation-crud.js";
+import { getDb } from "../../../../persistence/db-connection.js";
+import { initializeDb } from "../../../../persistence/db-init.js";
+import { messages } from "../../../../persistence/schema/index.js";
+import {
+  hasQualifyingUserMessageAfter,
+  messagesHaveUserActivity,
+} from "../memory-retrospective-accounting.js";
+
+await initializeDb();
+
+const CONV = "conv-accounting";
+
+const TEXT = JSON.stringify([{ type: "text", text: "hello" }]);
+const TOOL_RESULT_ONLY = JSON.stringify([
+  { type: "tool_result", tool_use_id: "t1", content: "ok" },
+]);
+const MIXED = JSON.stringify([
+  { type: "tool_result", tool_use_id: "t1", content: "ok" },
+  { type: "text", text: "note" },
+]);
+
+let seq = 0;
+function insertRaw(opts: {
+  role: string;
+  content: string;
+  createdAt: number;
+  id?: string;
+}): string {
+  const id = opts.id ?? `msg-${String(++seq).padStart(4, "0")}`;
+  getDb()
+    .insert(messages)
+    .values({
+      id,
+      conversationId: CONV,
+      role: opts.role,
+      content: opts.content,
+      createdAt: opts.createdAt,
+      metadata: null,
+    })
+    .run();
+  return id;
+}
+
+describe("hasQualifyingUserMessageAfter", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+    createConversation({ id: CONV });
+  });
+
+  test("assistant-only tail does not qualify", () => {
+    insertRaw({ role: "assistant", content: TEXT, createdAt: 1_000 });
+    insertRaw({ role: "assistant", content: TEXT, createdAt: 2_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(false);
+  });
+
+  test("tool_result-only user rows do not qualify", () => {
+    insertRaw({ role: "assistant", content: TEXT, createdAt: 1_000 });
+    insertRaw({ role: "user", content: TOOL_RESULT_ONLY, createdAt: 2_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(false);
+  });
+
+  test("a user text row qualifies", () => {
+    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
+  });
+
+  test("a mixed tool_result + text user row qualifies", () => {
+    insertRaw({ role: "user", content: MIXED, createdAt: 1_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
+  });
+
+  test("non-array user content qualifies (fails toward running)", () => {
+    // File-backed rows persist a `{ ref }` object; legacy rows persist a
+    // bare string. Neither shape can prove the row is a tool-result carrier.
+    insertRaw({
+      role: "user",
+      content: JSON.stringify({ ref: "deltas/abc" }),
+      createdAt: 1_000,
+    });
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
+
+    getDb().run(`DELETE FROM messages`);
+    insertRaw({ role: "user", content: "plain legacy text", createdAt: 1_000 });
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
+  });
+
+  test("an empty content array does not qualify", () => {
+    insertRaw({ role: "user", content: "[]", createdAt: 1_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(false);
+  });
+
+  test("only rows after the cursor count", () => {
+    const cursor = insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+    insertRaw({ role: "assistant", content: TEXT, createdAt: 2_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, cursor)).toBe(false);
+
+    insertRaw({ role: "user", content: TEXT, createdAt: 3_000 });
+    expect(hasQualifyingUserMessageAfter(CONV, cursor)).toBe(true);
+  });
+
+  test("the empty-string sentinel scans the whole conversation", () => {
+    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, "")).toBe(true);
+  });
+
+  test("a vanished cursor reference means no new work", () => {
+    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+
+    expect(hasQualifyingUserMessageAfter(CONV, "msg-gone")).toBe(false);
+  });
+
+  test("rows sharing the cursor's timestamp are split by the id tie-break", () => {
+    insertRaw({
+      role: "user",
+      content: TEXT,
+      createdAt: 1_000,
+      id: "msg-before",
+    });
+    insertRaw({
+      role: "user",
+      content: TOOL_RESULT_ONLY,
+      createdAt: 1_000,
+      id: "msg-cursor",
+    });
+    expect(hasQualifyingUserMessageAfter(CONV, "msg-cursor")).toBe(false);
+
+    insertRaw({
+      role: "user",
+      content: TEXT,
+      createdAt: 1_000,
+      id: "msg-later",
+    });
+    expect(hasQualifyingUserMessageAfter(CONV, "msg-cursor")).toBe(true);
+  });
+});
+
+describe("messagesHaveUserActivity", () => {
+  function row(
+    role: string,
+    content: Array<Record<string, unknown>>,
+  ): Pick<MessageRow, "role" | "content"> {
+    return { role, content } as unknown as Pick<MessageRow, "role" | "content">;
+  }
+
+  test("a user text row counts as user activity", () => {
+    expect(
+      messagesHaveUserActivity([
+        row("assistant", [{ type: "text", text: "recap" }]),
+        row("user", [{ type: "text", text: "hey" }]),
+      ]),
+    ).toBe(true);
+  });
+
+  test("tool_result-only user rows do not count", () => {
+    expect(
+      messagesHaveUserActivity([
+        row("assistant", [{ type: "text", text: "recap" }]),
+        row("user", [
+          { type: "tool_result", tool_use_id: "t1", content: "ok" },
+        ]),
+      ]),
+    ).toBe(false);
+  });
+
+  test("a mixed tool_result + text user row counts", () => {
+    expect(
+      messagesHaveUserActivity([
+        row("user", [
+          { type: "tool_result", tool_use_id: "t1", content: "ok" },
+          { type: "text", text: "note" },
+        ]),
+      ]),
+    ).toBe(true);
+  });
+
+  test("assistant rows never count, and an empty slice has no activity", () => {
+    expect(
+      messagesHaveUserActivity([
+        row("assistant", [{ type: "text", text: "hello" }]),
+      ]),
+    ).toBe(false);
+    expect(messagesHaveUserActivity([])).toBe(false);
+  });
+});

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

@@ -11,6 +11,19 @@ const upsertCalls: Array<{
   payload: { conversationId: string };
   runAfter: number;
 }> = [];
+let cfgRequireUserActivity = true;
+let mockStateRow: {
+  conversationId: string;
+  lastProcessedMessageId: string;
+  lastRunAt: number;
+  rememberedLog: string[];
+} | null = null;
+let tailQualifies = true;
+let gateProbeThrows = false;
+let gateProbeCalls: Array<{
+  conversationId: string;
+  afterMessageId: string | null;
+}> = [];
 
 mock.module("../../../../persistence/conversation-crud.js", () => ({
   getConversationSource: (_id: string) => sourceTag,
@@ -30,6 +43,29 @@ mock.module("../../../../persistence/jobs-store.js", () => ({
   },
 }));
 
+mock.module("../../../../config/loader.js", () => ({
+  getConfig: () => ({
+    memory: { retrospective: { requireUserActivity: cfgRequireUserActivity } },
+  }),
+}));
+
+mock.module("../memory-retrospective-state.js", () => ({
+  getRetrospectiveState: (_id: string) => mockStateRow,
+}));
+
+mock.module("../memory-retrospective-accounting.js", () => ({
+  hasQualifyingUserMessageAfter: (
+    conversationId: string,
+    afterMessageId: string | null,
+  ) => {
+    gateProbeCalls.push({ conversationId, afterMessageId });
+    if (gateProbeThrows) {
+      throw new Error("messages table unavailable");
+    }
+    return tailQualifies;
+  },
+}));
+
 import {
   enqueueMemoryRetrospectiveIfEnabled,
   enqueueMemoryRetrospectiveOnCompaction,
@@ -42,16 +78,22 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     convType = "standard";
     convSource = "user";
     upsertCalls.length = 0;
+    cfgRequireUserActivity = true;
+    mockStateRow = null;
+    tailQualifies = true;
+    gateProbeThrows = false;
+    gateProbeCalls = [];
   });
 
   test("standard source — interval trigger enqueues with runAfter ≈ now", () => {
     const before = Date.now();
-    enqueueMemoryRetrospectiveIfEnabled({
+    const result = enqueueMemoryRetrospectiveIfEnabled({
       conversationId: "c1",
       trigger: "interval",
     });
     const after = Date.now();
 
+    expect(result).toBe(true);
     expect(upsertCalls).toHaveLength(1);
     const call = upsertCalls[0]!;
     expect(call.payload).toEqual({ conversationId: "c1" });
@@ -59,6 +101,58 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     expect(call.runAfter).toBeLessThanOrEqual(after);
   });
 
+  test("assistant-only tail — user-activity gate skips the enqueue", () => {
+    tailQualifies = false;
+    const result = enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+
+    expect(result).toBe(false);
+    expect(upsertCalls).toHaveLength(0);
+  });
+
+  test("requireUserActivity=false — assistant-only tail still enqueues", () => {
+    cfgRequireUserActivity = false;
+    tailQualifies = false;
+    const result = enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+
+    expect(result).toBe(true);
+    expect(upsertCalls).toHaveLength(1);
+    expect(gateProbeCalls).toHaveLength(0);
+  });
+
+  test("gate probes the tail from the state row's cursor", () => {
+    mockStateRow = {
+      conversationId: "c1",
+      lastProcessedMessageId: "m9",
+      lastRunAt: 1,
+      rememberedLog: [],
+    };
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "sweep",
+    });
+
+    expect(gateProbeCalls).toEqual([
+      { conversationId: "c1", afterMessageId: "m9" },
+    ]);
+  });
+
+  test("an unevaluable gate fails open — the enqueue proceeds", () => {
+    gateProbeThrows = true;
+    const result = enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+
+    expect(result).toBe(true);
+    expect(upsertCalls).toHaveLength(1);
+  });
+
   test("compaction trigger applies the small debounce", () => {
     const before = Date.now();
     enqueueMemoryRetrospectiveIfEnabled({
@@ -135,6 +229,9 @@ describe("enqueueMemoryRetrospectiveOnCompaction", () => {
   beforeEach(() => {
     sourceTag = null;
     upsertCalls.length = 0;
+    cfgRequireUserActivity = true;
+    tailQualifies = true;
+    gateProbeThrows = false;
   });
 
   test("untrusted trust class — no enqueue", () => {

package/src/plugins/defaults/memory/__tests__/memory-retrospective-job.test.ts

@@ -28,7 +28,7 @@ let newMessages: Array<{
   id: string;
   createdAt: number;
   role?: string;
-  content?: string;
+  content?: string | Array<Record<string, unknown>>;
   metadata?: string | null;
 }> = [];
 
@@ -327,6 +327,7 @@ mock.module("../../../../config/memory-v3-gate.js", () => ({
 import type { MemoryJob } from "../../../../persistence/jobs-store.js";
 import {
   memoryRetrospectiveJob,
+  runForkBasedRetrospective,
   SOURCE_PROCESSING_REQUEUE_DELAY_MS,
 } from "../memory-retrospective-job.js";
 
@@ -337,6 +338,7 @@ function makeConfig(
     keepSupersededRuns?: boolean;
     matchConversationProfile?: boolean;
     promptPath?: string;
+    requireUserActivity?: boolean;
   } = {},
 ): Parameters<typeof memoryRetrospectiveJob>[1] {
   return {
@@ -346,6 +348,10 @@ function makeConfig(
         keepSupersededRuns: overrides.keepSupersededRuns ?? false,
         matchConversationProfile: overrides.matchConversationProfile ?? false,
         promptPath: overrides.promptPath ?? null,
+        // Neutral in the stub (the shipped schema default is true): the
+        // default `newMessages` rows carry no roles, so the gate's own tests
+        // opt in explicitly with role-shaped slices.
+        requireUserActivity: overrides.requireUserActivity ?? false,
         sweepIntervalMs: 8 * 60 * 60 * 1000,
         sweepLookbackMs: 7 * 24 * 60 * 60 * 1000,
       },
@@ -503,6 +509,104 @@ describe("memoryRetrospectiveJob", () => {
     ]);
   });
 
+  test("assistant-only slice with the user-activity gate on: completed as a no-op, both pointers untouched", async () => {
+    newMessages = [
+      {
+        id: "m1",
+        createdAt: Date.parse("2026-05-11T10:00:00Z"),
+        role: "assistant",
+        content: [{ type: "text", text: "proactive recap" }],
+      },
+      {
+        id: "m2",
+        createdAt: Date.parse("2026-05-11T10:05:00Z"),
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }],
+      },
+    ];
+
+    const outcome = await memoryRetrospectiveJob(
+      makeJob(),
+      makeConfig({ requireUserActivity: true }),
+    );
+
+    expect(outcome.kind).toBe("no_user_activity");
+    expect(stateUpserts).toHaveLength(0);
+    expect(lastRunAtBumps).toHaveLength(0);
+    expect(wakeCalls).toHaveLength(0);
+    expect(forkCalls).toHaveLength(0);
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "memory_retrospective_run"),
+    ).toEqual([
+      {
+        checkName: "memory_retrospective_run",
+        value: 1,
+        detail: { outcome: "no_user_activity" },
+      },
+    ]);
+  });
+
+  test("a user text row in the slice passes the user-activity gate", async () => {
+    newMessages = [
+      {
+        id: "m1",
+        createdAt: Date.parse("2026-05-11T10:00:00Z"),
+        role: "assistant",
+        content: [{ type: "text", text: "proactive recap" }],
+      },
+      {
+        id: "m2",
+        createdAt: Date.parse("2026-05-11T10:05:00Z"),
+        role: "user",
+        content: [{ type: "text", text: "hey" }],
+      },
+    ];
+
+    const outcome = await memoryRetrospectiveJob(
+      makeJob(),
+      makeConfig({ requireUserActivity: true }),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    expect(forkCalls).toHaveLength(1);
+  });
+
+  test("requireUserActivity=false: an assistant-only slice still runs", async () => {
+    newMessages = [
+      {
+        id: "m1",
+        createdAt: Date.parse("2026-05-11T10:00:00Z"),
+        role: "assistant",
+        content: [{ type: "text", text: "proactive recap" }],
+      },
+    ];
+
+    const outcome = await memoryRetrospectiveJob(
+      makeJob(),
+      makeConfig({ requireUserActivity: false }),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+  });
+
+  test("manual runs bypass the user-activity gate: no opts means an assistant-only slice runs", async () => {
+    newMessages = [
+      {
+        id: "m1",
+        createdAt: Date.parse("2026-05-11T10:00:00Z"),
+        role: "assistant",
+        content: [{ type: "text", text: "proactive recap" }],
+      },
+    ];
+
+    const outcome = await runForkBasedRetrospective(
+      "src-conv-1",
+      makeConfig({ requireUserActivity: true }),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+  });
+
   test("a slice whose only row is the retrospective's own skill card is no new work", async () => {
     // The card is inserted AFTER the cursor the run just persisted, so it is
     // always "after" lastProcessedMessageId — but it must never constitute

package/src/plugins/defaults/memory/__tests__/memory-retrospective-sweep.test.ts

@@ -2,14 +2,18 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // Record enqueues instead of writing job rows — the sweep's scan/gate decision
 // is the unit under test, not the jobs store's coalescing. The enqueue's own
-// recursion/low-yield guards are covered by memory-retrospective-enqueue tests.
+// recursion/low-yield/user-activity guards are covered by
+// memory-retrospective-enqueue tests; `enqueueDeclines` scripts a declined
+// conversation so the cap accounting can be asserted.
 let enqueueCalls: Array<{ conversationId: string; trigger: string }> = [];
+let enqueueDeclines = new Set<string>();
 mock.module("../memory-retrospective-enqueue.js", () => ({
   enqueueMemoryRetrospectiveIfEnabled: (args: {
     conversationId: string;
     trigger: string;
   }) => {
     enqueueCalls.push(args);
+    return !enqueueDeclines.has(args.conversationId);
   },
 }));
 
@@ -18,6 +22,7 @@ import { eq } from "drizzle-orm";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { AUTO_ANALYSIS_SOURCE } from "../../../../persistence/auto-analysis-constants.js";
 import { createConversation } from "../../../../persistence/conversation-crud.js";
+import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../../../persistence/conversation-types.js";
 import {
   getDb,
   getMemorySqlite,
@@ -38,7 +43,6 @@ import {
   runRetrospectiveSweep,
   SWEEP_MAX_ENQUEUES_PER_PASS,
 } from "../memory-retrospective-sweep.js";
-import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../substrate/constants.js";
 
 await initializeDb();
 
@@ -104,6 +108,7 @@ describe("runRetrospectiveSweep", () => {
   beforeEach(() => {
     resetTables();
     enqueueCalls = [];
+    enqueueDeclines = new Set();
   });
 
   test("never-run conversation with unprocessed messages is swept", async () => {
@@ -315,6 +320,23 @@ describe("runRetrospectiveSweep", () => {
     expect(result).toEqual({ scanned: 1, enqueued: 1 });
   });
 
+  test("an enqueue the funnel declines is not counted and does not consume the cap", async () => {
+    const declined = createConversation({ id: "conv-a" });
+    insertMessage(declined.id, { createdAt: 1_000 });
+    const accepted = createConversation({ id: "conv-b" });
+    insertMessage(accepted.id, { createdAt: 1_000 });
+    enqueueDeclines.add(declined.id);
+
+    const result = await runRetrospectiveSweep(makeConfig());
+
+    // Both conversations reach the funnel; only the accepted one counts.
+    expect(enqueueCalls.map((c) => c.conversationId)).toEqual([
+      declined.id,
+      accepted.id,
+    ]);
+    expect(result).toEqual({ scanned: 2, enqueued: 1 });
+  });
+
   test("enqueues clamp at the per-pass cap and defer the remainder", async () => {
     for (let i = 0; i < SWEEP_MAX_ENQUEUES_PER_PASS + 5; i++) {
       const conv = createConversation({