@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -148,6 +148,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       {
         slackInbound: {
           channelId: "C0123CHANNEL",
+          channelName: "engineering",
           channelTs: "1700000001.111111",
           threadTs: "1700000000.000001",
           displayName: "Alice",
@@ -162,6 +163,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
     expect(slackMeta!.source).toBe("slack");
     expect(slackMeta!.eventKind).toBe("message");
     expect(slackMeta!.channelId).toBe("C0123CHANNEL");
+    expect(slackMeta!.channelName).toBe("engineering");
     expect(slackMeta!.channelTs).toBe("1700000001.111111");
     expect(slackMeta!.threadTs).toBe("1700000000.000001");
     expect(slackMeta!.displayName).toBe("Alice");
@@ -194,6 +196,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
     expect(slackMeta!.channelTs).toBe("1700000010.222222");
     expect(slackMeta!.threadTs).toBeUndefined();
     expect(slackMeta!.displayName).toBe("Bob");
+    expect(slackMeta!.channelName).toBeUndefined();
   });
 
   test("Slack normalized content is persisted with raw channelTs in slackMeta", async () => {

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

@@ -0,0 +1,153 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let configBackgroundInjection: string =
+  "This is a background turn — your guardian isn't watching. If anything noteworthy comes up, send them a notification so they see it when they're back by invoking the `notifications` skill (`assistant notifications send --message \"...\"`)";
+
+const realLoaderForBackgroundTurnTest = await import("../config/loader.js");
+const realGetConfigForBackgroundTurnTest =
+  realLoaderForBackgroundTurnTest.getConfig;
+mock.module("../config/loader.js", () => ({
+  ...realLoaderForBackgroundTurnTest,
+  getConfig: () => {
+    const real = realGetConfigForBackgroundTurnTest();
+    return {
+      ...real,
+      conversations: {
+        ...real.conversations,
+        backgroundInjection: configBackgroundInjection,
+      },
+    };
+  },
+}));
+
+import {
+  DEFAULT_INJECTOR_ORDER,
+  defaultInjectorsPlugin,
+} from "../plugins/defaults/injectors.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { Injector, TurnContext } from "../plugins/types.js";
+
+function findInjector(name: string): Injector {
+  const injector = defaultInjectorsPlugin.injectors?.find(
+    (candidate) => candidate.name === name,
+  );
+  if (!injector) {
+    throw new Error(`injector '${name}' not registered`);
+  }
+  return injector;
+}
+
+function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    ...overrides,
+  };
+}
+
+const backgroundInjector = findInjector("background-turn");
+
+const DEFAULT_INJECTION_TEXT =
+  "This is a background turn — your guardian isn't watching. If anything noteworthy comes up, send them a notification so they see it when they're back by invoking the `notifications` skill (`assistant notifications send --message \"...\"`)";
+
+describe("background-turn injector", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultInjectorsPlugin);
+    configBackgroundInjection = DEFAULT_INJECTION_TEXT;
+  });
+
+  test("returns null when isBackgroundConversation is false", async () => {
+    const result = await backgroundInjector.produce(
+      makeContext({
+        injectionInputs: {
+          isBackgroundConversation: false,
+          isNonInteractive: true,
+        },
+      }),
+    );
+    expect(result).toBeNull();
+  });
+
+  test("returns null when isBackgroundConversation is unset", async () => {
+    const result = await backgroundInjector.produce(
+      makeContext({ injectionInputs: { isNonInteractive: true } }),
+    );
+    expect(result).toBeNull();
+  });
+
+  test("returns null when the guardian is actively connected (interactive turn)", async () => {
+    const result = await backgroundInjector.produce(
+      makeContext({
+        injectionInputs: {
+          isBackgroundConversation: true,
+          isNonInteractive: false,
+        },
+      }),
+    );
+    expect(result).toBeNull();
+  });
+
+  test("returns null when isNonInteractive is unset", async () => {
+    const result = await backgroundInjector.produce(
+      makeContext({ injectionInputs: { isBackgroundConversation: true } }),
+    );
+    expect(result).toBeNull();
+  });
+
+  test("wraps configured text in <background_turn> tags when active and non-interactive", async () => {
+    const block = await backgroundInjector.produce(
+      makeContext({
+        injectionInputs: {
+          isBackgroundConversation: true,
+          isNonInteractive: true,
+        },
+      }),
+    );
+
+    expect(block).toEqual({
+      id: "background-turn",
+      text: `<background_turn>\n${DEFAULT_INJECTION_TEXT}\n</background_turn>`,
+      placement: "prepend-user-tail",
+    });
+    expect(backgroundInjector.order).toBe(
+      DEFAULT_INJECTOR_ORDER.backgroundTurn,
+    );
+  });
+
+  test("returns null when configured text is the empty string", async () => {
+    configBackgroundInjection = "";
+
+    const result = await backgroundInjector.produce(
+      makeContext({
+        injectionInputs: {
+          isBackgroundConversation: true,
+          isNonInteractive: true,
+        },
+      }),
+    );
+    expect(result).toBeNull();
+  });
+
+  test("uses operator-configured override text verbatim", async () => {
+    configBackgroundInjection = "Custom reminder body.";
+
+    const block = await backgroundInjector.produce(
+      makeContext({
+        injectionInputs: {
+          isBackgroundConversation: true,
+          isNonInteractive: true,
+        },
+      }),
+    );
+
+    expect(block?.text).toBe(
+      "<background_turn>\nCustom reminder body.\n</background_turn>",
+    );
+  });
+});

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

@@ -95,12 +95,14 @@ describe("injector chain", () => {
     expect(names).toEqual([
       "disk-pressure-warning",
       "workspace-context",
+      "background-turn",
       "unified-turn-context",
       "pkb-context",
       "pkb-reminder",
       "memory-v2-static",
       "now-md",
       "active-documents",
+      "document-comments",
       "subagent-status",
       "slack-messages",
       "thread-focus",
@@ -117,6 +119,9 @@ describe("injector chain", () => {
     expect(byName.get("workspace-context")).toBe(
       DEFAULT_INJECTOR_ORDER.workspaceContext,
     );
+    expect(byName.get("background-turn")).toBe(
+      DEFAULT_INJECTOR_ORDER.backgroundTurn,
+    );
     expect(byName.get("unified-turn-context")).toBe(
       DEFAULT_INJECTOR_ORDER.unifiedTurnContext,
     );
@@ -154,6 +159,7 @@ describe("injector chain", () => {
     expect(names).toEqual([
       "disk-pressure-warning", // 5
       "workspace-context", // 10
+      "background-turn", // 15
       "unified-turn-context", // 20
       "plugin-25", // 25 — slots in
       "pkb-context", // 30
@@ -161,6 +167,7 @@ describe("injector chain", () => {
       "memory-v2-static", // 38
       "now-md", // 40
       "active-documents", // 45
+      "document-comments", // 46
       "subagent-status", // 50
       "slack-messages", // 60
       "thread-focus", // 70

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

@@ -0,0 +1,378 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { CommentRecord } from "../documents/document-comments-store.js";
+
+let listCommentsMock = mock((..._args: unknown[]) => [] as CommentRecord[]);
+
+mock.module("../documents/document-comments-store.js", () => ({
+  listComments: (...args: unknown[]) => listCommentsMock(...args),
+}));
+
+const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
+  await import("../plugins/defaults/injectors.js");
+import type { Injector, TurnContext } from "../plugins/types.js";
+
+function findInjector(name: string): Injector {
+  const injector = defaultInjectorsPlugin.injectors?.find(
+    (candidate) => candidate.name === name,
+  );
+  if (!injector) {
+    throw new Error(`injector '${name}' not registered`);
+  }
+  return injector;
+}
+
+function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    ...overrides,
+  };
+}
+
+function makeComment(overrides: Partial<CommentRecord> = {}): CommentRecord {
+  return {
+    id: "comment-abc",
+    surfaceId: "doc-1",
+    conversationId: "conv-test",
+    author: "user",
+    content: "Fix this paragraph",
+    anchorStart: null,
+    anchorEnd: null,
+    anchorText: null,
+    parentCommentId: null,
+    status: "open",
+    resolvedBy: null,
+    resolvedAt: null,
+    createdAt: 1000,
+    updatedAt: 1000,
+    ...overrides,
+  };
+}
+
+const injector = findInjector("document-comments");
+
+describe("document-comments injector", () => {
+  beforeEach(() => {
+    listCommentsMock = mock(() => [] as CommentRecord[]);
+  });
+
+  test("returns null when no active documents exist", async () => {
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: { mode: "full", activeDocuments: [] },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  test("returns null when activeDocuments is undefined", async () => {
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: { mode: "full" },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  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,
+            },
+          ],
+        },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  test("returns null when no documents have open comments", async () => {
+    listCommentsMock = mock(() => []);
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+    expect(block).toBeNull();
+  });
+
+  test("formats doc-level comments correctly", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({
+        id: "comment-id1",
+        content: "This introduction needs more context",
+        anchorText: null,
+      }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("document-comments");
+    expect(block!.placement).toBe("prepend-user-tail");
+    expect(block!.text).toContain("(doc-level)");
+    expect(block!.text).toContain("Comment #comment-id1");
+    expect(block!.text).toContain('"This introduction needs more context"');
+  });
+
+  test("formats inline comments with anchor text", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({
+        id: "comment-id2",
+        content: "Cite the research paper",
+        anchorText: "the quick brown fox",
+        anchorStart: 10,
+        anchorEnd: 29,
+      }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toContain('inline, anchored to "the quick brown fox"');
+    expect(block!.text).toContain("Comment #comment-id2");
+    expect(block!.text).toContain('"Cite the research paper"');
+  });
+
+  test("mixes doc-level and inline comments for the same document", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({
+        id: "comment-id1",
+        content: "This introduction needs more context",
+        anchorText: null,
+      }),
+      makeComment({
+        id: "comment-id2",
+        content: "Cite the research paper",
+        anchorText: "the quick brown fox",
+        anchorStart: 10,
+        anchorEnd: 29,
+      }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-xxx",
+              title: "Title",
+              wordCount: 200,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toContain('Document: "Title" (surface_id: "doc-xxx")');
+    expect(block!.text).toContain(
+      '- Comment #comment-id1 (doc-level): "This introduction needs more context"',
+    );
+    expect(block!.text).toContain(
+      '- Comment #comment-id2 (inline, anchored to "the quick brown fox"): "Cite the research paper"',
+    );
+  });
+
+  test("respects the 10-comment cap per document", async () => {
+    const comments = Array.from({ length: 15 }, (_, i) =>
+      makeComment({
+        id: `comment-${i}`,
+        content: `Comment number ${i}`,
+        createdAt: 1000 + i,
+      }),
+    );
+    listCommentsMock = mock(() => comments);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "Big Doc",
+              wordCount: 500,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    // The store returns ASC order; .slice(-10) takes the 10 most recent
+    for (let i = 5; i < 15; i++) {
+      expect(block!.text).toContain(`Comment #comment-${i}`);
+    }
+    // Earlier comments should be excluded (use exact line match to avoid
+    // substring collisions like "comment-1" matching "comment-10")
+    for (let i = 0; i < 5; i++) {
+      expect(block!.text).not.toContain(`Comment #comment-${i} (`);
+    }
+  });
+
+  test("handles multiple documents with comments", async () => {
+    let callCount = 0;
+    listCommentsMock = mock(() => {
+      callCount++;
+      if (callCount === 1) {
+        return [makeComment({ id: "c1", content: "Fix typo" })];
+      }
+      return [
+        makeComment({
+          id: "c2",
+          content: "Add citation",
+          anchorText: "some text",
+          anchorStart: 0,
+          anchorEnd: 9,
+        }),
+      ];
+    });
+
+    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,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toContain('Document: "Doc A" (surface_id: "doc-1")');
+    expect(block!.text).toContain('Document: "Doc B" (surface_id: "doc-2")');
+    expect(block!.text).toContain("Comment #c1");
+    expect(block!.text).toContain("Comment #c2");
+  });
+
+  test("skips documents with zero open comments", async () => {
+    let callCount = 0;
+    listCommentsMock = mock(() => {
+      callCount++;
+      if (callCount === 1) return [];
+      return [makeComment({ id: "c1", content: "Needs work" })];
+    });
+
+    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,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).not.toContain("Empty Doc");
+    expect(block!.text).toContain("Commented Doc");
+  });
+
+  test("has the correct order value", () => {
+    expect(injector.order).toBe(DEFAULT_INJECTOR_ORDER.documentComments);
+    expect(injector.order).toBe(46);
+  });
+
+  test("wraps output in <document_comments> tags with instructions", async () => {
+    listCommentsMock = mock(() => [
+      makeComment({ id: "c1", content: "Fix this" }),
+    ]);
+
+    const block = await injector.produce(
+      makeContext({
+        injectionInputs: {
+          mode: "full",
+          activeDocuments: [
+            {
+              surfaceId: "doc-1",
+              title: "My Doc",
+              wordCount: 100,
+              updatedAt: 1000,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toMatch(/^<document_comments>/);
+    expect(block!.text).toMatch(/<\/document_comments>$/);
+    expect(block!.text).toContain("comment_resolve");
+  });
+});

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

@@ -3,8 +3,8 @@
  *
  * When `getConfig().memory.v2.enabled` is true:
  *   - `pkb-context` silences itself (concept pages own retrieval).
- *   - `pkb-reminder` still fires (its body is generic recall/remember
- *     guidance) but skips the PKB-search hints — those name PKB paths.
+ *   - `pkb-reminder` silences itself (the v2 static `<memory>` block
+ *     supplants the generic recall/remember nudge).
  *   - `now-md` fires unchanged (workspace state, independent of PKB).
  *
  * Mocks `getConfig` at the module level so each test can flip the effective
@@ -85,7 +85,7 @@ describe("PKB injector v2 cutover behavior", () => {
     expect(texts.some((t) => t.includes("<NOW.md"))).toBe(true);
   });
 
-  test("v2 active → pkb-context silenced; pkb-reminder + now-md still fire", async () => {
+  test("v2 active → pkb-context and pkb-reminder silenced; now-md still fires", async () => {
     v2Active = true;
     const result = await applyRuntimeInjections(RUN_MESSAGES, {
       turnContext: makeTurnContext(),
@@ -99,29 +99,8 @@ describe("PKB injector v2 cutover behavior", () => {
 
     const texts = tailTexts(result.messages);
     expect(texts.some((t) => t.includes("<knowledge_base>"))).toBe(false);
-    expect(texts.some((t) => t.includes("<system_reminder>"))).toBe(true);
+    expect(texts.some((t) => t.includes("<system_reminder>"))).toBe(false);
     expect(texts.some((t) => t.includes("<NOW.md"))).toBe(true);
     expect(texts).toContain("What next?");
   });
-
-  test("v2 active → pkb-reminder body fires without the hybrid-search hints", async () => {
-    v2Active = true;
-    const result = await applyRuntimeInjections(RUN_MESSAGES, {
-      turnContext: makeTurnContext(),
-      pkbActive: true,
-      pkbScopeId: "scope-default",
-      pkbRoot: "/tmp/pkb",
-      pkbConversation: { messages: [] },
-      // Provide a query vector so the v1 path WOULD have called searchPkbFiles
-      // and rendered hints. Under v2, the call is skipped and the reminder
-      // is rendered with empty hints — i.e. no "files look especially
-      // relevant" line.
-      pkbQueryVector: [0.1, 0.2, 0.3],
-    });
-
-    const texts = tailTexts(result.messages);
-    const reminder = texts.find((t) => t.includes("<system_reminder>"));
-    expect(reminder).toBeDefined();
-    expect(reminder).not.toContain("files look especially relevant");
-  });
 });

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -71,6 +71,13 @@ mock.module("../memory/v2/skill-store.js", () => ({
   },
 }));
 
+// Mock the sibling CLI-command seeder so `rebuildBm25CorpusStatsAndReseedSkills`
+// (which runs both reseeds in parallel) does not invoke the real Qdrant-backed
+// implementation and emit warnings that break the no-warnings assertions below.
+mock.module("../memory/v2/cli-command-store.js", () => ({
+  seedV2CliCommandEntries: async (): Promise<void> => {},
+}));
+
 mock.module("../memory/v2/qdrant.js", () => ({
   ensureConceptPageCollection: async (): Promise<{ migrated: boolean }> => {
     state.ensureCollectionCallCount += 1;
@@ -312,10 +319,10 @@ describe("rebuildBm25CorpusStatsAndReseedSkills", () => {
     expect(state.warnCalls).toHaveLength(0);
   });
 
-  test("builds corpus stats but skips skill reseed when v2 is disabled", async () => {
+  test("skips both corpus stats and skill reseed when v2 is disabled", async () => {
     await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(false));
 
-    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.corpusStatsBuildCount).toBe(0);
     expect(state.seedCallCount).toBe(0);
     expect(state.warnCalls).toHaveLength(0);
   });