@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

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

@@ -1,17 +1,53 @@
-import { describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import * as dateContext from "../daemon/date-context.js";
+
+// `applyRuntimeInjections` computes the `<turn_context>` `current_time` live via
+// `formatTurnTimestamp`; pin it so the rendered block matches the deterministic
+// `buildUnifiedTurnContextBlock` expectation below. The rest of the module
+// (timezone canonicalization/resolution) keeps its real behavior.
+const FIXED_TURN_TIMESTAMP = "2026-04-02T12:00:00Z";
+mock.module("../daemon/date-context.js", () => ({
+  ...dateContext,
+  formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
+}));
 
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
   stripInjectionsForCompaction,
 } from "../daemon/conversation-runtime-assembly.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations, messages } from "../memory/schema.js";
+import {
+  type SlackMessageMetadata,
+  writeSlackMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
 import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectors,
   DISK_PRESSURE_WARNING_PROMPT,
-} from "../plugins/defaults/injectors/register.js";
+} from "../plugins/defaults/memory-retrieval/injectors.js";
+import { buildUnifiedTurnContextBlock } from "../plugins/defaults/memory-retrieval/unified-turn-context.js";
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
 
+// `applyRuntimeInjections` self-resolves the Slack active-thread focus block
+// from the persisted message rows, so the schema must exist for Slack-channel
+// turns; with no seeded rows the focus loader resolves to null.
+initializeDb();
+
+// `makeContext` and the workspace registry seed share this id so the
+// `workspace-context` injector resolves the seeded block for the turn.
+const TEST_CONVERSATION_ID = "conv-test";
+
 function findInjector(name: string): Injector {
   const injector = defaultInjectors.find(
     (candidate) => candidate.name === name,
@@ -25,7 +61,7 @@ function findInjector(name: string): Injector {
 function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
   return {
     requestId: "req-test",
-    conversationId: "conv-test",
+    conversationId: TEST_CONVERSATION_ID,
     turnIndex: 0,
     trust: { sourceChannel: "vellum", trustClass: "guardian" },
     ...overrides,
@@ -43,15 +79,134 @@ function tailTexts(messages: Message[]): string[] {
 }
 
 const diskPressureInjector = findInjector("disk-pressure-warning");
-const cleanupContext = { cleanupModeActive: true };
+
+// The disk-pressure-warning and workspace-context injectors both read their
+// per-conversation state off the live `Conversation` looked up by
+// `conversationId`. Seed a single fake instance under the id `makeContext()`
+// uses, carrying the disk-pressure flag and the workspace top-level cache, so a
+// turn can exercise both; the seed helpers mutate and re-register the same
+// instance. An empty (non-dirty) workspace cache resolves to no block, so
+// disk-pressure-only tests don't trigger a directory scan.
+let liveConversation: {
+  conversationId: string;
+  workingDir: string;
+  workspaceTopLevelContext: string | null;
+  workspaceTopLevelDirty: boolean;
+  diskPressureCleanupModeActive: boolean;
+  channelCapabilities?: ChannelCapabilities;
+  trustContext?: { trustClass: string };
+  currentTurnTemporalSnapshot?: {
+    clientTimezone: string | null;
+  };
+  currentTurnInterfaceContext?: {
+    userMessageInterface: string;
+    assistantMessageInterface: string;
+  };
+};
+
+function resetLiveConversation(): void {
+  liveConversation = {
+    conversationId: TEST_CONVERSATION_ID,
+    workingDir: "/workspace",
+    workspaceTopLevelContext: "",
+    workspaceTopLevelDirty: false,
+    diskPressureCleanupModeActive: false,
+    trustContext: { trustClass: "guardian" },
+    // The unified-turn-context injector sources the interface label from the
+    // live conversation's turn interface context; match the expected blocks.
+    currentTurnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    },
+  };
+}
+
+// `applyRuntimeInjections` gates the `<turn_context>` block on the live
+// conversation's frozen temporal snapshot (computing `current_time` live), so
+// seed it for tests that assert the unified-turn-context block is present.
+function seedTemporalSnapshot(): void {
+  liveConversation.currentTurnTemporalSnapshot = {
+    clientTimezone: null,
+  };
+  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+}
+
+function seedChannelCapabilities(caps: ChannelCapabilities): void {
+  liveConversation.channelCapabilities = caps;
+  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+}
+
+function seedDiskPressure(cleanupModeActive: boolean): void {
+  liveConversation.diskPressureCleanupModeActive = cleanupModeActive;
+  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+}
+
+function seedWorkspaceContext(text: string): void {
+  liveConversation.workspaceTopLevelContext = text;
+  liveConversation.workspaceTopLevelDirty = false;
+  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+}
+
+// Persist Slack-channel rows for the turn conversation so
+// `applyRuntimeInjections` self-resolves the chronological transcript from
+// conversation state, exactly as production does (the slack-messages injector
+// reads the live conversation rather than receiving a pre-built transcript).
+const SLACK_CHANNEL_ID = "C0123CHANNEL";
+function seedSlackChannelRows(
+  rows: Array<{
+    id: string;
+    text: string;
+    channelTs: string;
+    displayName: string;
+    createdAt: number;
+  }>,
+): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations)
+    .values({ id: TEST_CONVERSATION_ID, createdAt: now, updatedAt: now })
+    .onConflictDoNothing()
+    .run();
+  for (const r of rows) {
+    const meta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID,
+      channelTs: r.channelTs,
+      eventKind: "message",
+      displayName: r.displayName,
+    } as SlackMessageMetadata;
+    db.insert(messages)
+      .values({
+        id: r.id,
+        conversationId: TEST_CONVERSATION_ID,
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: r.text }]),
+        createdAt: r.createdAt,
+        metadata: JSON.stringify({
+          provenanceTrustClass: "guardian",
+          slackMeta: writeSlackMetadata(meta),
+        }),
+      })
+      .run();
+  }
+}
 
 describe("disk-pressure-warning injector", () => {
+  beforeEach(() => {
+    clearConversations();
+    resetLiveConversation();
+    const db = getDb();
+    db.delete(messages)
+      .where(eq(messages.conversationId, TEST_CONVERSATION_ID))
+      .run();
+    db.delete(conversations)
+      .where(eq(conversations.id, TEST_CONVERSATION_ID))
+      .run();
+  });
+
   test("emits the exact cleanup prompt during disk pressure cleanup mode", async () => {
-    const block = await diskPressureInjector.produce(
-      makeContext({
-        injectionInputs: { diskPressureContext: cleanupContext },
-      }),
-    );
+    seedDiskPressure(true);
+    const block = await diskPressureInjector.produce(makeContext());
 
     expect(block).toEqual({
       id: "disk-pressure-warning",
@@ -72,21 +227,14 @@ Do not work on unrelated tasks until enough space is freed to clear the lock or
 </disk_pressure_warning>`);
   });
 
-  test("omits the prompt when cleanup context is null or inactive", async () => {
+  test("omits the prompt when no cleanup context is registered or it is inactive", async () => {
     await expect(
-      diskPressureInjector.produce(
-        makeContext({ injectionInputs: { diskPressureContext: null } }),
-      ),
+      diskPressureInjector.produce(makeContext()),
     ).resolves.toBeNull();
 
+    seedDiskPressure(false);
     await expect(
-      diskPressureInjector.produce(
-        makeContext({
-          injectionInputs: {
-            diskPressureContext: { cleanupModeActive: false },
-          },
-        }),
-      ),
+      diskPressureInjector.produce(makeContext()),
     ).resolves.toBeNull();
   });
 
@@ -95,13 +243,16 @@ Do not work on unrelated tasks until enough space is freed to clear the lock or
       { role: "user", content: [{ type: "text", text: "clean up space" }] },
     ];
     const workspace = "<workspace>\nRoot: /workspace\n</workspace>";
-    const turnContext = "<turn_context>\ninterface: macos\n</turn_context>";
+    const turnContext = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+    });
 
+    seedWorkspaceContext(workspace);
+    seedDiskPressure(true);
+    seedTemporalSnapshot();
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeContext(),
-      diskPressureContext: cleanupContext,
-      workspaceTopLevelContext: workspace,
-      unifiedTurnContext: turnContext,
+      ...makeContext(),
     });
 
     expect(tailTexts(result.messages).slice(0, 4)).toEqual([
@@ -118,20 +269,23 @@ Do not work on unrelated tasks until enough space is freed to clear the lock or
   });
 
   test("survives minimal mode as safety-critical context", async () => {
+    const turnContext = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+    });
+    seedDiskPressure(true);
+    seedTemporalSnapshot();
     const result = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "status" }] }],
       {
-        turnContext: makeContext(),
+        ...makeContext(),
         mode: "minimal",
-        diskPressureContext: cleanupContext,
-        workspaceTopLevelContext: "<workspace>...</workspace>",
-        unifiedTurnContext: "<turn_context>...</turn_context>",
       },
     );
 
     expect(tailTexts(result.messages)).toEqual([
       DISK_PRESSURE_WARNING_PROMPT,
-      "<turn_context>...</turn_context>",
+      turnContext,
       "status",
     ]);
   });
@@ -143,28 +297,33 @@ Do not work on unrelated tasks until enough space is freed to clear the lock or
         content: [{ type: "text", text: "latest raw user text" }],
       },
     ];
-    const slackTranscript: Message[] = [
+
+    seedSlackChannelRows([
       {
-        role: "user",
-        content: [{ type: "text", text: "[12:00 user]: earlier" }],
+        id: "dp-1",
+        text: "earlier",
+        channelTs: "1700000000.000001",
+        displayName: "user",
+        createdAt: 1700000000_000,
       },
       {
-        role: "user",
-        content: [{ type: "text", text: "[12:01 @assistant]: cleanup?" }],
+        id: "dp-2",
+        text: "cleanup?",
+        channelTs: "1700000005.000001",
+        displayName: "user",
+        createdAt: 1700000005_000,
       },
-    ];
-
+    ]);
+    seedDiskPressure(true);
+    seedChannelCapabilities({
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    });
     const result = await applyRuntimeInjections(originalRun, {
-      turnContext: makeContext(),
-      diskPressureContext: cleanupContext,
-      channelCapabilities: {
-        channel: "slack",
-        dashboardCapable: false,
-        supportsDynamicUi: false,
-        supportsVoiceInput: false,
-        chatType: "channel",
-      },
-      slackChronologicalMessages: slackTranscript,
+      ...makeContext(),
     });
 
     expect(result.messages).toHaveLength(2);
@@ -173,7 +332,7 @@ Do not work on unrelated tasks until enough space is freed to clear the lock or
     expect(
       texts.some((text) => text.startsWith("<channel_capabilities>")),
     ).toBe(true);
-    expect(texts[texts.length - 1]).toBe("[12:01 @assistant]: cleanup?");
+    expect(texts[texts.length - 1]).toContain("cleanup?");
   });
 
   test("compaction strip plus re-apply does not duplicate the warning", async () => {
@@ -181,16 +340,15 @@ Do not work on unrelated tasks until enough space is freed to clear the lock or
       { role: "user", content: [{ type: "text", text: "find large files" }] },
     ];
 
+    seedDiskPressure(true);
     const first = await applyRuntimeInjections(runMessages, {
-      turnContext: makeContext(),
-      diskPressureContext: cleanupContext,
+      ...makeContext(),
     });
     const stripped = stripInjectionsForCompaction(first.messages);
     expect(tailTexts(stripped)).toEqual(["find large files"]);
 
     const second = await applyRuntimeInjections(stripped, {
-      turnContext: makeContext(),
-      diskPressureContext: cleanupContext,
+      ...makeContext(),
     });
     expect(
       tailTexts(second.messages).filter(

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

@@ -9,7 +9,7 @@ mock.module("../documents/document-comments-store.js", () => ({
 }));
 
 const { DEFAULT_INJECTOR_ORDER, defaultInjectors } =
-  await import("../plugins/defaults/injectors/register.js");
+  await import("../plugins/defaults/memory-retrieval/injectors.js");
 import type { Injector, TurnContext } from "../plugins/types.js";
 
 function findInjector(name: string): Injector {
@@ -62,7 +62,8 @@ describe("document-comments injector", () => {
   test("returns null when no active documents exist", async () => {
     const block = await injector.produce(
       makeContext({
-        injectionInputs: { mode: "full", activeDocuments: [] },
+        mode: "full",
+        activeDocuments: [],
       }),
     );
     expect(block).toBeNull();
@@ -71,7 +72,7 @@ describe("document-comments injector", () => {
   test("returns null when activeDocuments is undefined", async () => {
     const block = await injector.produce(
       makeContext({
-        injectionInputs: { mode: "full" },
+        mode: "full",
       }),
     );
     expect(block).toBeNull();
@@ -80,17 +81,15 @@ describe("document-comments injector", () => {
   test("returns null when mode is minimal", async () => {
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "minimal",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "My Doc",
-              wordCount: 100,
-              updatedAt: 1000,
-            },
-          ],
-        },
+        mode: "minimal",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "My Doc",
+            wordCount: 100,
+            updatedAt: 1000,
+          },
+        ],
       }),
     );
     expect(block).toBeNull();
@@ -100,17 +99,15 @@ describe("document-comments injector", () => {
     listCommentsMock = mock(() => []);
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "My Doc",
-              wordCount: 100,
-              updatedAt: 1000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "My Doc",
+            wordCount: 100,
+            updatedAt: 1000,
+          },
+        ],
       }),
     );
     expect(block).toBeNull();
@@ -127,17 +124,15 @@ describe("document-comments injector", () => {
 
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "My Doc",
-              wordCount: 100,
-              updatedAt: 1000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "My Doc",
+            wordCount: 100,
+            updatedAt: 1000,
+          },
+        ],
       }),
     );
 
@@ -162,17 +157,15 @@ describe("document-comments injector", () => {
 
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "My Doc",
-              wordCount: 100,
-              updatedAt: 1000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "My Doc",
+            wordCount: 100,
+            updatedAt: 1000,
+          },
+        ],
       }),
     );
 
@@ -200,17 +193,15 @@ describe("document-comments injector", () => {
 
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-xxx",
-              title: "Title",
-              wordCount: 200,
-              updatedAt: 1000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-xxx",
+            title: "Title",
+            wordCount: 200,
+            updatedAt: 1000,
+          },
+        ],
       }),
     );
 
@@ -236,17 +227,15 @@ describe("document-comments injector", () => {
 
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "Big Doc",
-              wordCount: 500,
-              updatedAt: 1000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "Big Doc",
+            wordCount: 500,
+            updatedAt: 1000,
+          },
+        ],
       }),
     );
 
@@ -282,23 +271,21 @@ describe("document-comments injector", () => {
 
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "Doc A",
-              wordCount: 100,
-              updatedAt: 1000,
-            },
-            {
-              surfaceId: "doc-2",
-              title: "Doc B",
-              wordCount: 200,
-              updatedAt: 2000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "Doc A",
+            wordCount: 100,
+            updatedAt: 1000,
+          },
+          {
+            surfaceId: "doc-2",
+            title: "Doc B",
+            wordCount: 200,
+            updatedAt: 2000,
+          },
+        ],
       }),
     );
 
@@ -319,23 +306,21 @@ describe("document-comments injector", () => {
 
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "Empty Doc",
-              wordCount: 100,
-              updatedAt: 1000,
-            },
-            {
-              surfaceId: "doc-2",
-              title: "Commented Doc",
-              wordCount: 200,
-              updatedAt: 2000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "Empty Doc",
+            wordCount: 100,
+            updatedAt: 1000,
+          },
+          {
+            surfaceId: "doc-2",
+            title: "Commented Doc",
+            wordCount: 200,
+            updatedAt: 2000,
+          },
+        ],
       }),
     );
 
@@ -356,17 +341,15 @@ describe("document-comments injector", () => {
 
     const block = await injector.produce(
       makeContext({
-        injectionInputs: {
-          mode: "full",
-          activeDocuments: [
-            {
-              surfaceId: "doc-1",
-              title: "My Doc",
-              wordCount: 100,
-              updatedAt: 1000,
-            },
-          ],
-        },
+        mode: "full",
+        activeDocuments: [
+          {
+            surfaceId: "doc-1",
+            title: "My Doc",
+            wordCount: 100,
+            updatedAt: 1000,
+          },
+        ],
       }),
     );
 

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

@@ -90,7 +90,7 @@ describe("PKB injector v2 cutover behavior", () => {
 
   test("v2 inactive → pkb-context, pkb-reminder, and now-md all produce blocks", async () => {
     const result = await applyRuntimeInjections(RUN_MESSAGES, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     const texts = tailTexts(result.messages);
@@ -102,7 +102,7 @@ describe("PKB injector v2 cutover behavior", () => {
   test("v2 active → pkb-context and pkb-reminder silenced; now-md still fires", async () => {
     v2Active = true;
     const result = await applyRuntimeInjections(RUN_MESSAGES, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     const texts = tailTexts(result.messages);