@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/conversation-slash-commands.test.ts

@@ -1,10 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  invalidateConfigCache,
-  loadRawConfig,
-} from "../config/loader.js";
+import { invalidateConfigCache, loadRawConfig } from "../config/loader.js";
 import {
   classifySlash,
   resolveSlash,
@@ -42,6 +39,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -58,6 +56,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -74,6 +73,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -87,6 +87,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -99,6 +100,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/model — List or switch inference profile",
       "/models — List all available models",
     ]);
@@ -187,13 +189,38 @@ describe("resolveSlash /compact target override", () => {
   });
 });
 
+describe("resolveSlash /clean", () => {
+  test("plain /clean resolves to kind=clean", async () => {
+    const result = await resolveSlash("/clean");
+    expect(result).toEqual({ kind: "clean" });
+  });
+
+  test("/clean tolerates surrounding whitespace", async () => {
+    const result = await resolveSlash("  /clean  ");
+    expect(result).toEqual({ kind: "clean" });
+  });
+
+  test("/clean is case-insensitive", async () => {
+    const result = await resolveSlash("/CLEAN");
+    expect(result).toEqual({ kind: "clean" });
+  });
+
+  test("/clean rejects arguments with usage hint", async () => {
+    const result = await resolveSlash("/clean now");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown");
+    expect(result.message).toContain("/clean");
+    expect(result.message).toContain("does not take arguments");
+  });
+});
+
 describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
   // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
   // effects. The pure classifier is synchronous, takes no side-effecting
   // dependencies, and must agree with resolveSlash's `kind`.
   const cases: Array<{
     input: string;
-    kind: "passthrough" | "compact" | "unknown";
+    kind: "passthrough" | "compact" | "clean" | "unknown";
   }> = [
     { input: "/models", kind: "unknown" },
     { input: "/context", kind: "unknown" },
@@ -204,6 +231,9 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/compact 30k", kind: "compact" },
     { input: "/compact 1.5M", kind: "compact" },
     { input: "/compact bogus", kind: "unknown" },
+    { input: "/clean", kind: "clean" },
+    { input: "  /clean  ", kind: "clean" },
+    { input: "/clean foo", kind: "unknown" },
     { input: "/model", kind: "unknown" },
     { input: "/model foo", kind: "unknown" },
     { input: "/opus", kind: "unknown" },
@@ -318,9 +348,7 @@ describe("resolveSlash /model — inference profile switcher", () => {
     const result = await resolveSlash("/model balanced");
     expect(result.kind).toBe("unknown");
     if (result.kind !== "unknown") throw new Error("expected unknown kind");
-    expect(result.message).toBe(
-      "Already using profile `balanced` (Balanced).",
-    );
+    expect(result.message).toBe("Already using profile `balanced` (Balanced).");
   });
 
   test("`/model` with no profiles defined points at Settings", async () => {

package/src/__tests__/conversation-slash-queue.test.ts

@@ -28,7 +28,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -24,7 +24,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

package/src/__tests__/conversation-speed-override.test.ts

@@ -48,7 +48,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 // Controllable config mock — speed and feature flag behavior are test-specific.

package/src/__tests__/conversation-store.test.ts

@@ -334,7 +334,7 @@ describe("attachment orphan cleanup", () => {
     const stored = uploadAttachment("doc.pdf", "application/pdf", "JVBER");
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    clearAll();
+    await clearAll();
 
     const raw = (
       getDb() as unknown as {

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -84,6 +84,95 @@ describe("task_progress surface compatibility", () => {
     expect(sent).toHaveLength(0);
   });
 
+  test("allows Slack ui_show for task_progress card when dynamic UI is otherwise disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Working",
+      template: "task_progress",
+      templateData: {
+        status: "in_progress",
+        steps: [{ label: "Start", status: "in_progress" }],
+      },
+    });
+
+    expect(result.isError).toBe(false);
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    );
+    expect(showMessage).toBeDefined();
+    if (!showMessage || showMessage.surfaceType !== "card") return;
+    expect((showMessage.data as CardSurfaceData).template).toBe(
+      "task_progress",
+    );
+  });
+
+  test("blocks Slack ui_show for non-task_progress card when dynamic UI is disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Blocked",
+      data: { title: "Blocked", body: "not progress" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_show is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_show when normalized card data is not task_progress", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Blocked",
+      template: "task_progress",
+      data: { title: "Blocked", body: "not progress", template: "plain" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_show is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_show for non-card task_progress input when dynamic UI is disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "dynamic_page",
+      title: "Blocked",
+      data: { template: "task_progress", html: "<p>Blocked</p>" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_show is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
   test("ui_show maps legacy top-level task_progress fields into card data", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);
@@ -249,6 +338,137 @@ describe("task_progress surface compatibility", () => {
     expect(Array.isArray(templateData.steps)).toBe(true);
   });
 
+  test("allows Slack ui_update for stored task_progress card when dynamic UI is disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: {
+        title: "Working",
+        body: "",
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: { status: "completed" },
+    });
+
+    expect(result.isError).toBe(false);
+    const updateMessage = sent.find(
+      (msg): msg is UiSurfaceUpdate => msg.type === "ui_surface_update",
+    );
+    expect(updateMessage).toBeDefined();
+    if (!updateMessage) return;
+    const templateData = (updateMessage.data as CardSurfaceData)
+      .templateData as Record<string, unknown>;
+    expect(templateData.status).toBe("completed");
+  });
+
+  test("blocks Slack ui_update when stored surface is not a task_progress card", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: { title: "Plain", body: "No progress" } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: { body: "still blocked" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_update that would convert a plain card to task_progress", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: { title: "Plain", body: "No progress" } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: {
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_update that would change task_progress card template", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: {
+        title: "Working",
+        body: "",
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: { template: "plain", body: "now a plain card" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+    expect(
+      (ctx.surfaceState.get("surface-1")?.data as CardSurfaceData).template,
+    ).toBe("task_progress");
+  });
+
+  test("blocks Slack ui_update when the surface is not already stored", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "missing-surface",
+      data: { status: "completed" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
   test("ui_show rejects new interactive surface when a non-dynamic_page pending surface exists", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

package/src/__tests__/conversation-sync-tags.test.ts

@@ -73,7 +73,16 @@ describe("conversation sync tags", () => {
     resetDb();
   });
 
-  test("rename emits legacy title/list events and conversation metadata sync tags", async () => {
+  test("rename emits the typed title event and a metadata-only sync tag (no list umbrella)", async () => {
+    // Rename is a content-only change: the row stays in place, the list
+    // shape is unchanged, only the title field flips. Web patches the
+    // single cached row via the typed `conversation_title_updated` event
+    // (`patchConversation` in `metadata-handlers.ts`) and the per-
+    // conversation `sync_changed` metadata tag is included as a belt-and-
+    // suspenders signal for sibling-tab consumers that missed the typed
+    // event. The legacy `conversation_list_invalidated` broadcast is
+    // scoped to `targetInterfaceId: "macos"` and therefore not visible to
+    // this process-type subscriber.
     const conversation = createConversation("Old title");
     const route = findRoute(
       CONVERSATION_MANAGEMENT_ROUTES,
@@ -85,23 +94,39 @@ describe("conversation sync tags", () => {
         pathParams: { id: conversation.id },
         body: { name: "New title" },
       });
-    }, 3);
+    }, 2);
 
     expect(received.map((event) => event.message.type)).toEqual([
       "conversation_title_updated",
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[2]!.message).toEqual({
+    expect(received[1]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    // Defense-in-depth: the umbrella `conversationsList` tag would force
+    // web to redrain the full paginated list — we deliberately omit it
+    // for content-only reasons.
+    expect(
+      (received[1]!.message as { tags: string[] }).tags,
+    ).not.toContain(SYNC_TAGS.conversationsList);
+    // The legacy invalidation broadcast is macOS-scoped and must not
+    // reach this process-type subscriber.
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("create emits legacy list invalidation and list/metadata sync tags", async () => {
+  test("create emits a sync_changed with the conversationsList umbrella tag", async () => {
+    // Create is shape-changing — a row is added to the paginated list,
+    // so web must redrain the list (cannot patch a row it has never
+    // fetched). The umbrella `conversationsList` tag is the signal for
+    // that redrain. Per-conversation metadata is included so any future
+    // single-row consumer can patch the freshly added row in place
+    // without an extra GET. The legacy macOS-only invalidation broadcast
+    // is not visible to process subscribers.
     const route = findRoute(
       CONVERSATION_MANAGEMENT_ROUTES,
       "createConversation",
@@ -113,23 +138,33 @@ describe("conversation sync tags", () => {
         body: { conversationKey: "sync-create-test" },
       })) as { id: string };
       conversationId = result.id;
-    }, 2);
+    }, 1);
 
     expect(conversationId).toBeDefined();
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
       tags: [
         SYNC_TAGS.conversationsList,
         conversationMetadataSyncTag(conversationId!),
       ],
     });
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("reorder emits list invalidation and metadata sync tags for touched conversations", async () => {
+  test("reorder emits a sync_changed with the umbrella tag and per-conversation metadata tags", async () => {
+    // Reorder changes the row position in the paginated list — also
+    // shape-changing. The umbrella `conversationsList` tag forces a
+    // redrain so the new ordering shows. Per-conversation metadata tags
+    // are bundled in to give any single-row consumer a hint that the
+    // touched conversations' positions have moved (currently web
+    // consumes only the umbrella tag; metadata tags are forward-compat).
     const first = createConversation("First");
     const second = createConversation("Second");
     const route = findRoute(
@@ -146,13 +181,12 @@ describe("conversation sync tags", () => {
           ],
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
       tags: [
         SYNC_TAGS.conversationsList,
@@ -160,9 +194,28 @@ describe("conversation sync tags", () => {
         conversationMetadataSyncTag(second.id),
       ],
     });
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("record seen emits list invalidation and metadata sync tags for the touched conversation", async () => {
+  test("record seen emits only a per-conversation metadata sync tag (no list umbrella)", async () => {
+    // Seen state is per-conversation attention metadata, not list-
+    // shaped. The old behavior emitted `sync_changed` carrying the
+    // umbrella `conversationsList` tag, which forced every subscribed
+    // web client to redrain the full paginated sidebar on every
+    // conversation switch that landed on an unseen conversation (~14
+    // requests at ~300 conversations). The current behavior emits a
+    // single `sync_changed` with only the per-conversation
+    // `conversation:<id>:metadata` tag, which web consumes by GET-and-
+    // patching the single cached row via `refreshConversationRow`.
+    //
+    // The legacy `conversation_list_invalidated` broadcast is still
+    // emitted for macOS (which has no per-row patcher) but is scoped
+    // to `targetInterfaceId: "macos"` and therefore not visible to
+    // this process-type subscriber.
     const conversation = createConversation("Attention");
     projectAssistantMessage({
       conversationId: conversation.id,
@@ -181,22 +234,32 @@ describe("conversation sync tags", () => {
           source: "test",
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    // Defense-in-depth: the umbrella `conversationsList` tag would
+    // force the very paginated-list drain this redesign exists to
+    // avoid. It must not appear here.
+    expect(
+      (received[0]!.message as { tags: string[] }).tags,
+    ).not.toContain(SYNC_TAGS.conversationsList);
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("mark unread emits list invalidation and metadata sync tags for the touched conversation", async () => {
+  test("mark unread emits only a per-conversation metadata sync tag (no list umbrella)", async () => {
+    // Symmetric with `record seen`: mark-unread flips the per-conversation
+    // hasUnseen flag back to true. Same per-conversation sync tag, same
+    // absence of list-level fan-out.
     const conversation = createConversation("Attention");
     projectAssistantMessage({
       conversationId: conversation.id,
@@ -218,18 +281,22 @@ describe("conversation sync tags", () => {
           conversationId: conversation.id,
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    expect(
+      (received[0]!.message as { tags: string[] }).tags,
+    ).not.toContain(SYNC_TAGS.conversationsList);
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 });

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -18,7 +18,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -87,6 +87,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -27,7 +27,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -116,6 +116,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -141,6 +142,9 @@ mock.module("../memory/conversation-crud.js", () => ({
   deleteLastExchange: () => 0,
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  setLastNotifiedInferenceProfile: () => {},
+  getConversationOverrideProfileFromRow: () => undefined,
+  updateMessageMetadata: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -25,7 +25,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -114,6 +114,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -138,6 +139,9 @@ mock.module("../memory/conversation-crud.js", () => ({
   deleteLastExchange: () => 0,
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  setLastNotifiedInferenceProfile: () => {},
+  getConversationOverrideProfileFromRow: () => undefined,
+  updateMessageMetadata: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({