@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/inbound-slack-persistence.test.ts

@@ -39,15 +39,21 @@ mock.module("../memory/conversation-crud.js", () => ({
     conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
+    addMessageCalls.push({
+      conversationId,
+      role,
+      content,
+      metadata: options?.metadata,
+    });
     return { id: `persisted-${addMessageCalls.length}` };
   },
   getConversation: () => null,
   provenanceFromTrustContext: () => ({}),
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -140,12 +146,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Reply inside a thread",
-      [],
-      "req-thread",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Reply inside a thread",
+      requestId: "req-thread",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelName: "engineering",
@@ -155,8 +159,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
           actorExternalUserId: "U_ALICE",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -176,20 +179,17 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Top-level channel post",
-      [],
-      "req-top",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Top-level channel post",
+      requestId: "req-top",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000010.222222",
           displayName: "Bob",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -205,20 +205,17 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "@leo can you check this?",
-      [],
-      "req-normalized-content",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "@leo can you check this?",
+      requestId: "req-normalized-content",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000015.123456",
           displayName: "Alice",
         },
       },
-      undefined,
-    );
+    });
 
     expect(JSON.parse(addMessageCalls.at(-1)!.content)).toEqual([
       { type: "text", text: "@leo can you check this?" },
@@ -236,19 +233,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Anonymous channel post",
-      [],
-      "req-anon",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Anonymous channel post",
+      requestId: "req-anon",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000020.333333",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -261,14 +255,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "telegram",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Telegram message",
-      [],
-      "req-tg",
-      undefined,
-      undefined,
-    );
+    await persistQueuedMessageBody(ctx, {
+      content: "Telegram message",
+      requestId: "req-tg",
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -284,19 +274,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "telegram",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Telegram message with stray slackInbound",
-      [],
-      "req-tg-stray",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Telegram message with stray slackInbound",
+      requestId: "req-tg-stray",
+      metadata: {
         slackInbound: {
           channelId: "C0_DOES_NOT_APPLY",
           channelTs: "1700000030.444444",
         },
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -312,14 +299,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Slack wake without inbound metadata",
-      [],
-      "req-no-slack-inbound",
-      undefined,
-      undefined,
-    );
+    await persistQueuedMessageBody(ctx, {
+      content: "Slack wake without inbound metadata",
+      requestId: "req-no-slack-inbound",
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -331,19 +314,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Malformed inbound payload",
-      [],
-      "req-malformed",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Malformed inbound payload",
+      requestId: "req-malformed",
+      metadata: {
         slackInbound: {
           // channelTs intentionally missing — simulates a bug upstream.
           channelId: "C0123CHANNEL",
         } as unknown as Record<string, unknown>,
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -355,19 +335,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Verify carrier is stripped",
-      [],
-      "req-strip",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Verify carrier is stripped",
+      requestId: "req-strip",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000040.555555",
         },
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackInbound" in metadata).toBe(false);

package/src/__tests__/inference-profile-reaper.test.ts

@@ -12,7 +12,7 @@ import {
   getConversation,
   setConversationInferenceProfileSession,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
@@ -20,6 +20,7 @@ import {
   stopInferenceProfileSessionReaper,
   tickInferenceProfileReaper,
 } from "../runtime/routes/inference-profile-session-reaper.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -40,7 +41,7 @@ describe("inference-profile-session-reaper", () => {
 
   afterAll(() => {
     stopInferenceProfileSessionReaper();
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -38,9 +38,10 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -66,7 +67,7 @@ function clearTables(): void {
 describe("inference_profile_open IPC op", () => {
   beforeEach(clearTables);
   afterAll(() => {
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

package/src/__tests__/injector-background-turn.test.ts

@@ -23,7 +23,7 @@ mock.module("../config/loader.js", () => ({
 import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectorsPlugin,
-} from "../plugins/defaults/injectors.js";
+} from "../plugins/defaults/injectors/register.js";
 import {
   registerPlugin,
   resetPluginRegistryForTests,

package/src/__tests__/injector-chain.test.ts

@@ -45,7 +45,7 @@ mock.module("../config/loader.js", () => ({
 const { applyRuntimeInjections, composeInjectorChain } =
   await import("../daemon/conversation-runtime-assembly.js");
 const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors.js");
+  await import("../plugins/defaults/injectors/register.js");
 import {
   getInjectors,
   registerPlugin,

package/src/__tests__/injector-disk-pressure.test.ts

@@ -1,6 +1,5 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   applyRuntimeInjections,
   stripInjectionsForCompaction,
@@ -9,7 +8,7 @@ import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectorsPlugin,
   DISK_PRESSURE_WARNING_PROMPT,
-} from "../plugins/defaults/injectors.js";
+} from "../plugins/defaults/injectors/register.js";
 import {
   registerPlugin,
   resetPluginRegistryForTests,
@@ -54,10 +53,9 @@ describe("disk-pressure-warning injector", () => {
   beforeEach(() => {
     resetPluginRegistryForTests();
     registerPlugin(defaultInjectorsPlugin);
-    _setOverridesForTesting({ "safe-storage-limits": true });
   });
 
-  test("emits the exact cleanup prompt while safe storage limits are enabled", async () => {
+  test("emits the exact cleanup prompt during disk pressure cleanup mode", async () => {
     const block = await diskPressureInjector.produce(
       makeContext({
         injectionInputs: { diskPressureContext: cleanupContext },
@@ -73,13 +71,13 @@ describe("disk-pressure-warning injector", () => {
       DEFAULT_INJECTOR_ORDER.diskPressureWarning,
     );
     expect(DISK_PRESSURE_WARNING_PROMPT).toBe(`<disk_pressure_warning>
-Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is at least 95% full.
+Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is critically full.
 
 In your first paragraph, warn the user that storage is critically low and that normal work is suspended until space is freed.
 
 Then help the user clean up storage. Prefer safe inspection steps first, such as checking available space and finding large directories. Ask before deleting files or caches unless the user has already clearly approved the specific cleanup action.
 
-Do not work on unrelated tasks until disk usage drops below the critical threshold or the user explicitly overrides the lock. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
+Do not work on unrelated tasks until enough space is freed to clear the lock or the user explicitly overrides it. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
 </disk_pressure_warning>`);
   });
 
@@ -101,18 +99,6 @@ Do not work on unrelated tasks until disk usage drops below the critical thresho
     ).resolves.toBeNull();
   });
 
-  test("omits the prompt when safe storage limits are disabled", async () => {
-    _setOverridesForTesting({ "safe-storage-limits": false });
-
-    await expect(
-      diskPressureInjector.produce(
-        makeContext({
-          injectionInputs: { diskPressureContext: cleanupContext },
-        }),
-      ),
-    ).resolves.toBeNull();
-  });
-
   test("prepends ahead of workspace and unified turn context in full mode", async () => {
     const runMessages: Message[] = [
       { role: "user", content: [{ type: "text", text: "clean up space" }] },

package/src/__tests__/injector-document-comments.test.ts

@@ -9,7 +9,7 @@ mock.module("../documents/document-comments-store.js", () => ({
 }));
 
 const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors.js");
+  await import("../plugins/defaults/injectors/register.js");
 import type { Injector, TurnContext } from "../plugins/types.js";
 
 function findInjector(name: string): Injector {

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -30,7 +30,7 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
 const { applyRuntimeInjections } =
   await import("../daemon/conversation-runtime-assembly.js");
 const { defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors.js");
+  await import("../plugins/defaults/injectors/register.js");
 const { registerPlugin, resetPluginRegistryForTests } =
   await import("../plugins/registry.js");
 import type { TurnContext } from "../plugins/types.js";

package/src/__tests__/injector-v3-suppression.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Tests for the memory-v3-live v2-suppression branch in
+ * `applyRuntimeInjections` (PR L6 of the memory-v3-live plan).
+ *
+ * When `suppressV2MemoryForV3` is on AND the v3 injector (id `memory-v3`,
+ * placement `after-memory-prefix`) actually produces a block, runtime
+ * assembly strips the v2 `<memory>` prefix from EVERY user message before
+ * splicing the v3 block — so v3 becomes the sole `<memory>` source and history
+ * is byte-stable for prompt caching.
+ *
+ * Keyed off whether v3 produced a block, NOT off the option alone: a v3
+ * failure (`produce()` → null) leaves v2's block intact (fallback-to-v2).
+ *
+ * The flag-off path must be byte-for-byte identical to today — that is the
+ * load-bearing regression guard.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getInjectors,
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type {
+  InjectionBlock,
+  Injector,
+  Plugin,
+  TurnContext,
+} from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+
+const { applyRuntimeInjections } =
+  await import("../daemon/conversation-runtime-assembly.js");
+
+function makeTurnContext(): TurnContext {
+  return {
+    requestId: "req-test-1",
+    conversationId: "conv-test-1",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+  };
+}
+
+function wrapInPlugin(name: string, injectors: Injector[]): Plugin {
+  return { manifest: { name, version: "0.0.1" }, injectors };
+}
+
+/**
+ * A fake v3 injector that mirrors the real one's id + placement. The real
+ * injector's `renderMemoryBlock` already wraps its content in
+ * `<memory>\n…\n</memory>`, so the fake does too — `inner === null` means the
+ * injector produced nothing this turn (error/empty selection).
+ */
+function v3Injector(inner: string | null): Injector {
+  return {
+    name: "memory-v3-shadow",
+    order: 1000,
+    async produce(): Promise<InjectionBlock | null> {
+      if (inner === null) return null;
+      return {
+        id: "memory-v3",
+        text: `<memory>\n${inner}\n</memory>`,
+        placement: "after-memory-prefix",
+      };
+    },
+  };
+}
+
+/** Build a user message whose tail carries a v2 `<memory>` prefix block. */
+function userMsgWithV2Memory(memoryText: string, userText: string): Message {
+  return {
+    role: "user",
+    content: [
+      { type: "text", text: `<memory>\n${memoryText}\n</memory>` },
+      { type: "text", text: userText },
+    ],
+  };
+}
+
+/** Extract the tail user message's text blocks. */
+function tailTexts(messages: Message[]): string[] {
+  const tail = messages[messages.length - 1];
+  return tail.content
+    .filter((b): b is { type: "text"; text: string } => b.type === "text")
+    .map((b) => b.text);
+}
+
+describe("memory-v3-live v2 suppression", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("flag ON + v3 produced a block → v2 stripped from all turns, exactly one <memory> (the v3 block)", async () => {
+    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+
+    // History: a prior user turn that still carries a v2 block (rehydrated),
+    // plus the current tail user turn with its own v2 block.
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("old recalled fact", "earlier question"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "earlier answer" }],
+      },
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: true,
+    });
+
+    // Exactly one <memory> source across the WHOLE assembled context.
+    const allTexts = result.messages.flatMap((m) =>
+      m.content
+        .filter((b): b is { type: "text"; text: string } => b.type === "text")
+        .map((b) => b.text),
+    );
+    const memoryBlocks = allTexts.filter((t) => t.startsWith("<memory>"));
+    expect(memoryBlocks).toHaveLength(1);
+    // And it is the v3 block, not a v2 one.
+    expect(memoryBlocks[0]).toBe("<memory>\nv3 working set\n</memory>");
+
+    // The historical user turn no longer carries its v2 block (all-turns strip).
+    const firstUser = result.messages[0];
+    expect(
+      firstUser.content.every(
+        (b) => !(b.type === "text" && b.text.startsWith("<memory>")),
+      ),
+    ).toBe(true);
+
+    // The v3 block lands at the head of the tail user message; original user
+    // text is preserved right after it.
+    const texts = tailTexts(result.messages);
+    expect(texts[0]).toBe("<memory>\nv3 working set\n</memory>");
+    expect(texts[1]).toBe("current question");
+    expect(texts).toHaveLength(2);
+  });
+
+  test("flag ON but v3 produced NOTHING → v2 block left intact (fallback-to-v2)", async () => {
+    registerPlugin(wrapInPlugin("v3", [v3Injector(null)]));
+
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: true,
+    });
+
+    // v2's block survives — the turn still ships memory.
+    const texts = tailTexts(result.messages);
+    expect(texts[0]).toBe("<memory>\nfresh recalled fact\n</memory>");
+    expect(texts[1]).toBe("current question");
+    // No v3 block was added.
+    expect(texts).toHaveLength(2);
+  });
+
+  test("flag OFF → byte-for-byte identical to today even when v3 would have produced a block", async () => {
+    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("old recalled fact", "earlier question"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "earlier answer" }],
+      },
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    // With suppression off, the v3 injector still runs through the chain
+    // (after-memory-prefix), but NO v2 stripping happens. This captures the
+    // exact pre-flag assembly behavior: v2 prefix stays, v3 splices after it.
+    const offResult = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: false,
+    });
+
+    // The tail keeps v2's block AND gains v3's (the historical double-injection
+    // the suppression PR exists to prevent) — proving suppression is the ONLY
+    // behavior change and it is fully gated off here.
+    const texts = tailTexts(offResult.messages);
+    expect(texts[0]).toBe("<memory>\nfresh recalled fact\n</memory>");
+    expect(texts[1]).toBe("<memory>\nv3 working set\n</memory>");
+    expect(texts[2]).toBe("current question");
+
+    // Historical user turn keeps its v2 block (no all-turns strip when off).
+    const firstUserTexts = offResult.messages[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(firstUserTexts[0]).toBe("<memory>\nold recalled fact\n</memory>");
+
+    // Strongest guard: omitting the option entirely yields the SAME result as
+    // passing it false — the default path is untouched by this PR.
+    resetPluginRegistryForTests();
+    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+    const defaultResult = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+    });
+    expect(defaultResult.messages).toEqual(offResult.messages);
+  });
+
+  test("no v3 injector registered + flag ON → no stripping, messages untouched", async () => {
+    // No injector named memory-v3 at all (e.g. plugin not loaded): the
+    // suppression branch keys off the produced block, so nothing is stripped.
+    expect(getInjectors()).toHaveLength(0);
+
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: true,
+    });
+
+    expect(result.messages).toEqual(runMessages);
+  });
+});

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -69,10 +69,10 @@ mockIpcResponse("get_global_thresholds", {
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import { check, generateAllowlistOptions } from "../permissions/checker.js";
 import { clearRiskCache } from "../permissions/checker.js";
 import { _clearGlobalCacheForTesting } from "../permissions/gateway-threshold-reader.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────
 
@@ -115,7 +115,7 @@ describe("inline-command skill_load permissions", () => {
   beforeEach(() => {
     clearRiskCache();
     _clearGlobalCacheForTesting();
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
     mockIpcResponse("get_global_thresholds", {
       interactive: "low",
       autonomous: "medium",
@@ -135,7 +135,7 @@ describe("inline-command skill_load permissions", () => {
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   // ── Default behavior ─────────────────────────────────────────────────
@@ -197,7 +197,7 @@ describe("inline-command skill_load permissions", () => {
       writeDynamicSkill("dynamic-flag-off", "Dynamic Flag Off Skill");
 
       // Disable the feature flag
-      _setOverridesForTesting({
+      setOverridesForTesting({
         "inline-skill-commands": false,
       });