@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/assistant-event-hub-self-exclusion.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Tests for self-echo suppression in `AssistantEventHub`.
+ *
+ * Validates:
+ *   - hub.publish(event, { excludeClientId }) skips the matching client
+ *     subscriber and delivers to every other matching subscriber.
+ *   - Suppression is unconditional: it applies whether the broadcast is
+ *     untargeted, conversation-scoped, or capability-targeted.
+ *   - `broadcastMessage(sync_changed { originClientId })` derives the
+ *     exclusion from the message itself — no caller wiring needed.
+ *   - `broadcastMessage(sync_changed)` without an originClientId fans out
+ *     to every subscriber (the daemon-internal emit path).
+ *   - Process-type subscribers are never excluded by a clientId match.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import {
+  AssistantEventHub,
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+
+function makeSyncChangedEvent(originClientId?: string): AssistantEvent {
+  return {
+    id: "evt_test_sync",
+    conversationId: undefined,
+    emittedAt: "2026-05-03T00:00:00.000Z",
+    message: {
+      type: "sync_changed",
+      tags: ["conversation:abc:messages"],
+      ...(originClientId ? { originClientId } : {}),
+    },
+  };
+}
+
+describe("AssistantEventHub — self-echo suppression (excludeClientId)", () => {
+  test("skips the named client and delivers to every other client", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+    const receivedC: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-c",
+      interfaceId: "macos",
+      capabilities: [],
+      callback: (e) => {
+        receivedC.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent("client-a"), {
+      excludeClientId: "client-a",
+    });
+
+    expect(receivedA).toHaveLength(0);
+    expect(receivedB).toHaveLength(1);
+    expect(receivedC).toHaveLength(1);
+  });
+
+  test("delivers to every subscriber when excludeClientId is omitted", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent());
+
+    expect(receivedA).toHaveLength(1);
+    expect(receivedB).toHaveLength(1);
+  });
+
+  test("excludeClientId does not match process-type subscribers", async () => {
+    const hub = new AssistantEventHub();
+    const receivedProcess: AssistantEvent[] = [];
+
+    // A process subscriber sits in the same hub as a client whose id
+    // matches `excludeClientId`. It must never be suppressed because
+    // `excludeClientId` only matches `type: "client"` entries — process
+    // entries have no `clientId` field at all.
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        receivedProcess.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent("client-a"), {
+      excludeClientId: "client-a",
+    });
+
+    expect(receivedProcess).toHaveLength(1);
+  });
+
+  test("excludeClientId composes with conversation-scoped subscribers", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      filter: { conversationId: "sess_x" },
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      filter: { conversationId: "sess_x" },
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    // Scoped event for sess_x; both clients filter to sess_x; exclude A.
+    const event: AssistantEvent = {
+      id: "evt_scoped",
+      conversationId: "sess_x",
+      emittedAt: "2026-05-03T00:00:00.000Z",
+      message: {
+        type: "sync_changed",
+        tags: ["conversation:sess_x:messages"],
+        originClientId: "client-a",
+      },
+    };
+
+    await hub.publish(event, { excludeClientId: "client-a" });
+
+    expect(receivedA).toHaveLength(0);
+    expect(receivedB).toHaveLength(1);
+  });
+});
+
+describe("broadcastMessage — derives excludeClientId from sync_changed.originClientId", () => {
+  test("skips the originating client when originClientId is present", async () => {
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    const subB = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+        originClientId: "broadcast-a",
+      });
+      // broadcastMessage queues onto a microtask chain — yield until it
+      // drains. Two awaits cover the publish promise + its `.then` chain.
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(0);
+      expect(receivedB).toHaveLength(1);
+    } finally {
+      subA.dispose();
+      subB.dispose();
+    }
+  });
+
+  test("fans out to every client when originClientId is absent", async () => {
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-c",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    const subB = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-d",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+      });
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(1);
+      expect(receivedB).toHaveLength(1);
+    } finally {
+      subA.dispose();
+      subB.dispose();
+    }
+  });
+
+  test("ignores an empty-string originClientId (treats as absent)", async () => {
+    const receivedA: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-e",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+        // Exercise the length-zero guard. `originClientId?: string` accepts
+        // empty strings at the type level, but production code path can't
+        // produce one — `buildSyncChangedMessage` trims and drops empty
+        // values before calling `broadcastMessage`.
+        originClientId: "",
+      });
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(1);
+    } finally {
+      subA.dispose();
+    }
+  });
+});

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -4,7 +4,7 @@
  * Covers:
  *   - Missing persisted value falls back to code default
  *   - Protected feature-flags.json is the sole override mechanism
- *   - Undeclared keys default to enabled
+ *   - Undeclared keys default to disabled
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
@@ -80,10 +80,10 @@ describe("isAssistantFeatureFlagEnabled", () => {
     ).toBe(true);
   });
 
-  test("unknown flag defaults to true when no persisted override", () => {
+  test("unknown flag defaults to false when no persisted override", () => {
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled("unknown-skill", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("unknown-skill", config)).toBe(false);
   });
 
   test("undeclared flag respects persisted override", () => {

package/src/__tests__/audit-log-rotation.test.ts

@@ -69,72 +69,126 @@ describe("audit log rotation", () => {
     clearTable();
   });
 
-  test("returns 0 when retentionDays is 0 (retain forever)", () => {
+  test("returns 0 when retentionDays is 0 (retain forever)", async () => {
     addInvocation(100 * ONE_DAY_MS); // 100 days old
-    const deleted = rotateToolInvocations(0);
+    const deleted = await rotateToolInvocations(0);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("returns 0 when retentionDays is negative", () => {
+  test("returns 0 when retentionDays is negative", async () => {
     addInvocation(100 * ONE_DAY_MS);
-    const deleted = rotateToolInvocations(-5);
+    const deleted = await rotateToolInvocations(-5);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("deletes records older than retentionDays", () => {
+  test("deletes records older than retentionDays", async () => {
     addInvocation(10 * ONE_DAY_MS); // 10 days old — should be deleted with 7-day retention
     addInvocation(3 * ONE_DAY_MS); // 3 days old — should be kept
     addInvocation(1 * ONE_DAY_MS); // 1 day old — should be kept
 
-    const deleted = rotateToolInvocations(7);
+    const deleted = await rotateToolInvocations(7);
     expect(deleted).toBe(1);
     expect(getRecentInvocations(100).length).toBe(2);
   });
 
-  test("keeps all records when none exceed retention", () => {
+  test("keeps all records when none exceed retention", async () => {
     addInvocation(1 * ONE_DAY_MS);
     addInvocation(2 * ONE_DAY_MS);
     addInvocation(3 * ONE_DAY_MS);
 
-    const deleted = rotateToolInvocations(30);
+    const deleted = await rotateToolInvocations(30);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(3);
   });
 
-  test("deletes all records when all exceed retention", () => {
+  test("deletes all records when all exceed retention", async () => {
     addInvocation(60 * ONE_DAY_MS);
     addInvocation(90 * ONE_DAY_MS);
     addInvocation(120 * ONE_DAY_MS);
 
-    const deleted = rotateToolInvocations(30);
+    const deleted = await rotateToolInvocations(30);
     expect(deleted).toBe(3);
     expect(getRecentInvocations(100).length).toBe(0);
   });
 
-  test("returns 0 when table is empty", () => {
-    const deleted = rotateToolInvocations(7);
+  test("returns 0 when table is empty", async () => {
+    const deleted = await rotateToolInvocations(7);
     expect(deleted).toBe(0);
   });
 
-  test("handles 1-day retention (deletes everything older than 24h)", () => {
+  test("handles 1-day retention (deletes everything older than 24h)", async () => {
     addInvocation(2 * ONE_DAY_MS); // 2 days old — delete
     addInvocation(12 * 60 * 60 * 1000); // 12 hours old — keep
 
-    const deleted = rotateToolInvocations(1);
+    const deleted = await rotateToolInvocations(1);
     expect(deleted).toBe(1);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("works with recordToolInvocation (via ORM)", () => {
+  test("works with recordToolInvocation (via ORM)", async () => {
     // Use raw SQL to insert (avoids db singleton issues in parallel test runs)
     // and verify the rotation/query functions work correctly with it
     addInvocation(0); // just-created record
 
     // This record was just created, so it should not be rotated
-    const deleted = rotateToolInvocations(1);
+    const deleted = await rotateToolInvocations(1);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
+
+  test(
+    "yields to the event loop while the purge is in flight (anti-block)",
+    async () => {
+      // Seed a few thousand rows so the DELETE has measurable
+      // subprocess work behind the scenes.
+      const ROW_COUNT = 2000;
+      const past = 100 * ONE_DAY_MS;
+      const sqlite = getSqlite();
+      sqlite.exec("BEGIN");
+      try {
+        for (let i = 0; i < ROW_COUNT; i++) {
+          addInvocation(past);
+        }
+        sqlite.exec("COMMIT");
+      } catch (err) {
+        sqlite.exec("ROLLBACK");
+        throw err;
+      }
+
+      // Race the purge against a `setImmediate` ping. The ping
+      // resolves on the very next event-loop iteration after it is
+      // scheduled.
+      //
+      // If the purge is async (subprocess), `rotateToolInvocations`
+      // returns a pending Promise immediately; the ping wins the race
+      // while the subprocess is still running.
+      //
+      // If the purge is ever regressed back to a synchronous DELETE,
+      // `rotateToolInvocations` blocks the main thread for the full
+      // DELETE duration. `setImmediate` cannot fire until the main
+      // thread releases, so the purge's already-resolved Promise
+      // beats the ping through the microtask queue and "purge" wins.
+      //
+      // The signal is deterministic regardless of how fast the
+      // subprocess is or how busy the event loop is.
+      const ping = new Promise<"ping">((resolve) =>
+        setImmediate(() => resolve("ping")),
+      );
+      const purgePromise = rotateToolInvocations(7);
+      const winner = await Promise.race([
+        ping,
+        purgePromise.then(() => "purge" as const),
+      ]);
+
+      expect(winner).toBe("ping");
+
+      // Drain the purge so the log + subprocess cleanup complete
+      // before the test exits.
+      const deleted = await purgePromise;
+      expect(deleted).toBe(ROW_COUNT);
+    },
+    60_000,
+  );
 });

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -108,7 +108,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: mock(() => ({ id: "msg-1" })),
   archiveConversation: mock(() => true),
   batchSetDisplayOrders: mock(() => {}),
-  clearStrippedInjectionMetadataForConversation: mock(() => {}),
   createConversation: (opts: { conversationType: string }) => {
     createdConversations.push(opts);
     return { id: "conv-1", ...opts };
@@ -116,7 +115,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   countConversationsByScheduleJobId: mock(() => 0),
   countMessagesAfter: mock(() => 0),
   deleteMessageById: mock(() => {}),
-  clearAll: mock(() => ({ conversations: 0, messages: 0 })),
+  clearAll: mock(async () => ({ conversations: 0, messages: 0 })),
   deleteConversation: mock(() => ({ memoryIds: [] })),
   deleteLastExchange: mock(() => 0),
   findAnalysisConversationFor: mock(() => null),
@@ -131,7 +130,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationSource: () => null,
   getAssistantMessageIdsInTurn: () => [],
   getDisplayMetaForConversations: () => new Map(),
-  getLastAssistantTimestampBefore: () => null,
   getLastUserTimestampBefore: () => null,
   getMessageById: () => null,
   getMessages: () => [],
@@ -156,6 +154,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationSlackContextWatermark: mock(() => {}),
   updateConversationTitle: mock(() => {}),
   updateConversationUsage: mock(() => {}),
+  setLastNotifiedInferenceProfile: mock(() => {}),
+  setConversationHistoryStrippedAt: mock(() => {}),
   wipeConversation: mock(() => ({ memoryIds: [] })),
 }));
 
@@ -181,6 +181,7 @@ mock.module("../memory/jobs-store.js", () => ({
   failStalledJobs: mockFailStalledJobs,
   getMemoryJobCounts: mock(() => ({})),
   hasActiveJobOfType: mock(() => false),
+  isMemoryEnabled: () => true,
   resetRunningJobsToPending: mock(() => 0),
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),

package/src/__tests__/btw-routes.test.ts

@@ -317,12 +317,11 @@ describe("POST /v1/btw", () => {
 
     expect(tools).toEqual(MOCK_TOOLS);
     expect(systemPrompt).toBe(MOCK_SYSTEM_PROMPT);
+    // Persona is resolved internally now; btw-routes no longer plumbs
+    // it through to buildSystemPrompt.
     expect(mockBuildSystemPrompt).toHaveBeenCalledWith({
-      channelPersona: null,
       excludeBootstrap: true,
       excludeCustomPrefix: true,
-      userPersona: null,
-      userSlug: null,
     });
     expect(options!.config!.tool_choice).toEqual({ type: "none" });
     expect(options!.config!.callSite).toBe("identityIntro");

package/src/__tests__/call-controller.test.ts

@@ -166,7 +166,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     reason: "mocked",
     deliveryResults: [],
   }),
-  registerBroadcastFn: () => {},
 }));
 
 mock.module("../calls/voice-session-bridge.js", () => {

package/src/__tests__/cancel-resolves-conversation-key.test.ts

@@ -49,7 +49,7 @@ mock.module("../daemon/handlers/conversations.js", () => ({
     return true;
   },
   switchConversation: async () => null,
-  clearAllConversations: () => 0,
+  clearAllConversations: async () => 0,
   undoLastMessage: async () => null,
   regenerateResponse: async () => null,
 }));