@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/host-transfer-proxy.test.ts

@@ -8,7 +8,14 @@ const sentMessages: unknown[] = [];
 let mockHasClient = false;
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  broadcastMessage: (msg: unknown) => {
+    // Skip `interaction_resolved` envelopes — pending-interactions emits one
+    // on every resolve and these tests assert on host-proxy wire messages.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
+    sentMessages.push(msg);
+  },
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_file" && mockHasClient ? { id: "mock-client" } : null,

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

@@ -24,8 +24,12 @@ mock.module("../util/logger.js", () => ({
 
 import {
   handleDetailedHealth,
+  handleReadyz,
   ROUTES,
 } from "../runtime/routes/identity-routes.js";
+import {
+  setCesClient,
+} from "../security/secure-keys.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import {
   getHatchedSidecarPath,
@@ -177,6 +181,59 @@ describe("identity routes — health endpoint", () => {
       expect(body.timestamp).toBeDefined();
       expect(body.migrations).toBeDefined();
     });
+
+    test("includes ces.connected=false when no CES client is registered", async () => {
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.ces).toBeDefined();
+      expect((body.ces as Record<string, unknown>).connected).toBe(false);
+    });
+  });
+
+  describe("CES readiness", () => {
+    beforeEach(() => {
+      setCesClient(undefined);
+    });
+
+    test("readyz returns 200 and logs warning when CES is unavailable", () => {
+      const res = handleReadyz();
+      expect(res.status).toBe(200);
+    });
+
+    test("readyz returns 200 when CES is connected and ready", () => {
+      const mockClient = { isReady: () => true, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleReadyz();
+      expect(res.status).toBe(200);
+    });
+
+    test("readyz returns 200 when CES client exists but is not ready", () => {
+      const mockClient = { isReady: () => false, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleReadyz();
+      expect(res.status).toBe(200);
+    });
+
+    test("/v1/health reports ces.connected=true when CES is ready", async () => {
+      const mockClient = { isReady: () => true, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.ces).toBeDefined();
+      expect((body.ces as Record<string, unknown>).connected).toBe(true);
+    });
+
+    test("/v1/health reports ces.connected=false when CES is not ready", async () => {
+      const mockClient = { isReady: () => false, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      setCesClient(mockClient);
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.ces).toBeDefined();
+      expect((body.ces as Record<string, unknown>).connected).toBe(false);
+    });
   });
 
   describe("profiler payload (profiler enabled)", () => {

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__/init-feature-flag-overrides.test.ts

@@ -47,9 +47,9 @@ describe("initFeatureFlagOverrides", () => {
     // through the backoff schedule.
     await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
-    // Without gateway data or file, undeclared flags default to true
+    // Without gateway data or file, undeclared flags default to false
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(false);
   });
 
   it("respects false values from gateway IPC", async () => {
@@ -72,10 +72,9 @@ describe("initFeatureFlagOverrides", () => {
     // through the production backoff schedule.
     await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
-    // Undeclared flags without overrides default to true (not false from
-    // a cached empty map)
+    // Undeclared flags without overrides default to false.
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(false);
   });
 
   it("retries empty gateway responses and picks up flags once they become available", async () => {
@@ -111,6 +110,6 @@ describe("initFeatureFlagOverrides", () => {
     // first-call must still be true (from the cached first fetch)
     expect(isAssistantFeatureFlagEnabled("first-call", config)).toBe(true);
     // second-call should not be in the cache since init was a no-op
-    expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(true); // defaults to true (undeclared)
+    expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(false);
   });
 });

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

@@ -102,6 +102,7 @@ describe("injector chain", () => {
       "memory-v2-static",
       "now-md",
       "active-documents",
+      "document-comments",
       "subagent-status",
       "slack-messages",
       "thread-focus",
@@ -166,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");
-  });
 });