@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/host-shell-tool.test.ts

@@ -32,15 +32,10 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
   auditLog: { retentionDays: 0 },
 };
 
-// Track whether wrapCommand was ever called — host_bash must never invoke it
-let wrapCommandCallCount = 0;
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
@@ -59,10 +54,22 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: (...args: unknown[]) => {
-    wrapCommandCallCount++;
-    return { command: "bash", args: ["-c", "--", args[0]], sandboxed: false };
+// Mock the host-bash-proxy singleton so proxy delegation tests can control it.
+let mockProxyAvailable = false;
+let mockProxyRequestFn: (
+  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string> },
+  conversationId: string,
+  signal?: AbortSignal,
+) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+
+mock.module("../daemon/host-bash-proxy.js", () => ({
+  HostBashProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockProxyAvailable,
+        request: mockProxyRequestFn,
+      };
+    },
   },
 }));
 
@@ -83,6 +90,8 @@ afterEach(() => {
   for (const dir of testDirs.splice(0)) {
     rmSync(dir, { recursive: true, force: true });
   }
+  mockProxyAvailable = false;
+  mockProxyRequestFn = () => Promise.resolve({ content: "", isError: false });
 });
 
 describe("host_bash tool", () => {
@@ -125,8 +134,6 @@ describe("host_bash tool", () => {
   });
 
   test("does not route through sandbox wrapCommand", async () => {
-    wrapCommandCallCount = 0;
-
     const dir = mkdtempSync(join(tmpdir(), "host-shell-nosandbox-"));
     testDirs.push(dir);
 
@@ -140,8 +147,6 @@ describe("host_bash tool", () => {
 
     expect(result.isError).toBe(false);
     expect(result.content.trim()).toBe("isolation-test");
-    // The sandbox wrapCommand must never be called for host_bash
-    expect(wrapCommandCallCount).toBe(0);
   });
 
   test("spawns plain bash without sandbox-exec or bwrap", async () => {
@@ -236,7 +241,6 @@ describe("host_bash — baseline: no sandbox isolation", () => {
     testDirs.push(dir);
 
     spawnCalls.length = 0;
-    wrapCommandCallCount = 0;
 
     const result = await hostShellTool.execute(
       {
@@ -247,7 +251,6 @@ describe("host_bash — baseline: no sandbox isolation", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(wrapCommandCallCount).toBe(0);
     expect(spawnCalls[0].command).toBe("bash");
   });
 });
@@ -289,7 +292,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     testDirs.push(dir);
 
     spawnCalls.length = 0;
-    wrapCommandCallCount = 0;
 
     // Pass network_mode as if the model hallucinated the parameter —
     // host_bash must ignore it and run the command normally.
@@ -308,7 +310,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     expect(spawnCalls.length).toBe(1);
     expect(spawnCalls[0].command).toBe("bash");
     // Must never route through sandbox wrapCommand, even with proxied-mode input
-    expect(wrapCommandCallCount).toBe(0);
   });
 
   test("execute ignores credential_ids even if supplied in input", async () => {
@@ -316,7 +317,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     testDirs.push(dir);
 
     spawnCalls.length = 0;
-    wrapCommandCallCount = 0;
 
     const result = await hostShellTool.execute(
       {
@@ -332,7 +332,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     expect(spawnCalls.length).toBe(1);
     expect(spawnCalls[0].command).toBe("bash");
     // Must never route through sandbox wrapCommand, even with credential inputs
-    expect(wrapCommandCallCount).toBe(0);
   });
 
   test("tool name is host_bash (not bash)", () => {
@@ -721,7 +720,7 @@ describe("host_bash — proxy delegation", () => {
     }
   }
 
-  function makeMockProxy(result: ToolExecutionResult) {
+  function setupMockProxy(result: ToolExecutionResult) {
     const calls: Array<{
       input: {
         command: string;
@@ -732,41 +731,24 @@ describe("host_bash — proxy delegation", () => {
       conversationId: string;
     }> = [];
 
-    return {
-      proxy: {
-        isAvailable: () => true,
-        request: async (
-          input: {
-            command: string;
-            working_dir?: string;
-            timeout_seconds?: number;
-            env?: Record<string, string>;
-          },
-          conversationId: string,
-          _signal?: AbortSignal,
-        ) => {
-          calls.push({ input, conversationId });
-          return result;
-        },
-        updateSender: () => {},
-        dispose: () => {},
-        resolve: () => {},
-        hasPendingRequest: () => false,
-      },
-      calls,
+    mockProxyAvailable = true;
+    mockProxyRequestFn = async (input, conversationId) => {
+      calls.push({ input, conversationId });
+      return result;
     };
+
+    return calls;
   }
 
-  test("delegates to proxy when hostBashProxy is available", async () => {
+  test("delegates to proxy when proxy is available", async () => {
     const proxyResult: ToolExecutionResult = {
       content: "proxied output",
       isError: false,
     };
-    const { proxy, calls } = makeMockProxy(proxyResult);
+    const calls = setupMockProxy(proxyResult);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     };
 
     spawnCalls.length = 0;
@@ -790,11 +772,10 @@ describe("host_bash — proxy delegation", () => {
       content: "proxied",
       isError: false,
     };
-    const { proxy, calls } = makeMockProxy(proxyResult);
+    const calls = setupMockProxy(proxyResult);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     };
 
     const result = await hostShellTool.execute({ command: "echo \0evil" }, ctx);
@@ -810,11 +791,10 @@ describe("host_bash — proxy delegation", () => {
       content: "proxied",
       isError: false,
     };
-    const { proxy, calls } = makeMockProxy(proxyResult);
+    const calls = setupMockProxy(proxyResult);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     };
 
     const result = await hostShellTool.execute(
@@ -828,24 +808,12 @@ describe("host_bash — proxy delegation", () => {
   });
 
   test("falls back to local execution when proxy is not available", async () => {
-    const unavailableProxy = {
-      isAvailable: () => false,
-      request: async () => {
-        throw new Error("should not be called");
-      },
-      updateSender: () => {},
-      dispose: () => {},
-      resolve: () => {},
-      hasPendingRequest: () => false,
-    };
-
+    // mockProxyAvailable defaults to false, so isAvailable() returns false
     const dir = mkdtempSync(join(tmpdir(), "host-shell-proxy-fallback-"));
     testDirs.push(dir);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy:
-        unavailableProxy as unknown as ToolContext["hostBashProxy"],
     };
 
     spawnCalls.length = 0;
@@ -894,12 +862,11 @@ describe("host_bash — proxy delegation", () => {
         content: "proxied",
         isError: false,
       };
-      const { proxy, calls } = makeMockProxy(proxyResult);
+      const calls = setupMockProxy(proxyResult);
 
       const ctx: ToolContext = {
         ...makeContext(),
         trustClass: "trusted_contact", // untrusted actor
-        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
       };
 
       const result = await hostShellTool.execute(
@@ -930,12 +897,11 @@ describe("host_bash — proxy delegation", () => {
         content: "proxied",
         isError: false,
       };
-      const { proxy, calls } = makeMockProxy(proxyResult);
+      const calls = setupMockProxy(proxyResult);
 
       const ctx: ToolContext = {
         ...makeContext(),
         trustClass: "guardian", // trusted actor — no lockdown
-        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
       };
 
       const result = await hostShellTool.execute(
@@ -969,12 +935,11 @@ describe("host_bash — proxy delegation", () => {
         content: "proxied",
         isError: false,
       };
-      const { proxy, calls } = makeMockProxy(proxyResult);
+      const calls = setupMockProxy(proxyResult);
 
       const ctx: ToolContext = {
         ...makeContext(),
         trustClass: "guardian", // trusted actor — no lockdown
-        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
       };
 
       const result = await hostShellTool.execute(

package/src/__tests__/host-transfer-pending-interactions.test.ts

@@ -9,7 +9,6 @@
  */
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { Conversation } from "../daemon/conversation.js";
 import type {
   HostTransferCancelRequest,
   HostTransferRequest,
@@ -19,14 +18,6 @@ import type {
 } from "../daemon/message-protocol.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function stubConversation(id: string): Conversation {
-  return { id } as unknown as Conversation;
-}
-
 // ---------------------------------------------------------------------------
 // Message type compilation checks
 // ---------------------------------------------------------------------------
@@ -65,6 +56,7 @@ describe("HostTransfer message types", () => {
     const msg: HostTransferCancelRequest = {
       type: "host_transfer_cancel",
       requestId: "req-3",
+      conversationId: "conv-1",
     };
     const _sm: ServerMessage = msg;
     expect(_sm.type).toBe("host_transfer_cancel");
@@ -105,9 +97,7 @@ describe("host_transfer pending interactions", () => {
   });
 
   test("host_transfer can be registered as a pending interaction", () => {
-    const conv = stubConversation("conv-1");
     pendingInteractions.register("req-1", {
-      conversation: conv,
       conversationId: "conv-1",
       kind: "host_transfer",
     });
@@ -119,21 +109,17 @@ describe("host_transfer pending interactions", () => {
   });
 
   test("host_transfer interactions survive removeByConversation", () => {
-    const conv = stubConversation("conv-1");
-
     // Register a confirmation (should be removed) and a host_transfer (should survive)
     pendingInteractions.register("confirm-1", {
-      conversation: conv,
       conversationId: "conv-1",
       kind: "confirmation",
     });
     pendingInteractions.register("transfer-1", {
-      conversation: conv,
       conversationId: "conv-1",
       kind: "host_transfer",
     });
 
-    pendingInteractions.removeByConversation(conv);
+    pendingInteractions.removeByConversation("conv-1");
 
     // Confirmation should be gone
     expect(pendingInteractions.get("confirm-1")).toBeUndefined();
@@ -143,9 +129,7 @@ describe("host_transfer pending interactions", () => {
   });
 
   test("host_transfer interactions can be resolved", () => {
-    const conv = stubConversation("conv-1");
     pendingInteractions.register("req-1", {
-      conversation: conv,
       conversationId: "conv-1",
       kind: "host_transfer",
     });

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

@@ -2,7 +2,30 @@ import { createHash } from "node:crypto";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, afterEach, describe, expect, test } from "bun:test";
+import { afterAll, afterEach, describe, expect, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+const resolvedInteractionIds: string[] = [];
+let mockHasClient = false;
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_file" && mockHasClient ? { id: "mock-client" } : null,
+  },
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  resolve: (requestId: string) => {
+    resolvedInteractionIds.push(requestId);
+    return undefined;
+  },
+  get: () => undefined,
+  getByKind: () => [],
+  getByConversation: () => [],
+  removeByConversation: () => {},
+}));
 
 const { HostTransferProxy } = await import("../daemon/host-transfer-proxy.js");
 
@@ -29,18 +52,18 @@ async function waitForMessages(
 
 describe("HostTransferProxy", () => {
   let proxy: InstanceType<typeof HostTransferProxy>;
-  let sentMessages: unknown[];
-  let sendToClient: (msg: unknown) => void;
   let tempDir: string;
 
-  function setup(onInternalResolve?: (requestId: string) => void) {
-    sentMessages = [];
-    sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostTransferProxy(sendToClient, onInternalResolve);
+  function setup() {
+    sentMessages.length = 0;
+    resolvedInteractionIds.length = 0;
+    mockHasClient = false;
+    proxy = new (HostTransferProxy as any)();
   }
 
   afterEach(async () => {
     proxy?.dispose();
+    HostTransferProxy.reset();
     if (tempDir) {
       await rm(tempDir, { recursive: true, force: true }).catch(() => {});
     }
@@ -533,24 +556,17 @@ describe("HostTransferProxy", () => {
   });
 
   describe("isAvailable", () => {
-    test("returns false by default (no client connected)", () => {
+    test("returns false when no client with host_file capability is connected", () => {
       setup();
+      mockHasClient = false;
       expect(proxy.isAvailable()).toBe(false);
     });
 
-    test("returns true after updateSender with clientConnected=true", () => {
+    test("returns true when a client with host_file capability is connected", () => {
       setup();
-      proxy.updateSender(sendToClient, true);
+      mockHasClient = true;
       expect(proxy.isAvailable()).toBe(true);
     });
-
-    test("returns false after updateSender with clientConnected=false", () => {
-      setup();
-      proxy.updateSender(sendToClient, true);
-      expect(proxy.isAvailable()).toBe(true);
-      proxy.updateSender(sendToClient, false);
-      expect(proxy.isAvailable()).toBe(false);
-    });
   });
 
   describe("dispose", () => {
@@ -626,33 +642,9 @@ describe("HostTransferProxy", () => {
     });
   });
 
-  describe("updateSender", () => {
-    test("uses updated sender for new requests", async () => {
-      setup();
-
-      const newMessages: unknown[] = [];
-      proxy.updateSender((msg) => newMessages.push(msg), true);
-
-      const resultPromise = proxy.requestToSandbox({
-        sourcePath: "/host/source.txt",
-        destPath: "/sandbox/dest.txt",
-        conversationId: "conv-123",
-      });
-
-      expect(sentMessages).toHaveLength(0);
-      expect(newMessages).toHaveLength(1);
-
-      // Cancel to avoid hanging
-      const sent = newMessages[0] as Record<string, unknown>;
-      proxy.cancel(sent.requestId as string);
-      await resultPromise;
-    });
-  });
-
-  describe("onInternalResolve callback", () => {
+  describe("pendingInteractions.resolve callback", () => {
     test("fires on abort", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+      setup();
 
       const controller = new AbortController();
       const resultPromise = proxy.requestToSandbox(
@@ -670,12 +662,11 @@ describe("HostTransferProxy", () => {
       controller.abort();
       await resultPromise;
 
-      expect(resolvedIds).toEqual([requestId]);
+      expect(resolvedInteractionIds).toContain(requestId);
     });
 
     test("fires for each pending request on dispose", () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+      setup();
 
       const p1 = proxy.requestToSandbox({
         sourcePath: "/host/a.txt",
@@ -697,14 +688,13 @@ describe("HostTransferProxy", () => {
 
       proxy.dispose();
 
-      expect(resolvedIds).toHaveLength(2);
-      expect(resolvedIds).toContain(ids[0]);
-      expect(resolvedIds).toContain(ids[1]);
+      expect(resolvedInteractionIds).toHaveLength(2);
+      expect(resolvedInteractionIds).toContain(ids[0]);
+      expect(resolvedInteractionIds).toContain(ids[1]);
     });
 
     test("does not fire on normal resolveTransferResult", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+      setup();
       tempDir = await mkdtemp(join(tmpdir(), "htp-test-"));
       const srcPath = join(tempDir, "source.txt");
       await globalThis.Bun.write(srcPath, "content");
@@ -727,7 +717,7 @@ describe("HostTransferProxy", () => {
       });
 
       await resultPromise;
-      expect(resolvedIds).toEqual([]);
+      expect(resolvedInteractionIds).toEqual([]);
     });
   });
 });

package/src/__tests__/http-user-message-parity.test.ts

@@ -124,8 +124,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     secretDetection: {
       enabled: true,
-      customPatterns: [],
-      entropyThreshold: 3.5,
     },
     model: "test",
     provider: "test",
@@ -206,11 +204,7 @@ function makeConversation(overrides: Record<string, unknown> = {}) {
   return {
     setTrustContext: () => {},
     updateClient: () => {},
-    setHostBashProxy: () => {},
     setHostBrowserProxy: () => {},
-    setHostFileProxy: () => {},
-    setHostTransferProxy: () => {},
-    getHostTransferProxy: () => undefined,
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},
     emitConfirmationStateChanged: () => {},

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

@@ -194,6 +194,37 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
     expect(slackMeta!.displayName).toBe("Bob");
   });
 
+  test("Slack normalized content is persisted with raw channelTs in slackMeta", async () => {
+    const ctx = createTestContext({
+      userMessageChannel: "slack",
+      assistantMessageChannel: "slack",
+    });
+
+    await persistQueuedMessageBody(
+      ctx,
+      "@leo can you check this?",
+      [],
+      "req-normalized-content",
+      {
+        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?" },
+    ]);
+
+    const slackMeta = readPersistedSlackMeta();
+    expect(slackMeta).not.toBeNull();
+    expect(slackMeta!.channelTs).toBe("1700000015.123456");
+    expect(slackMeta!.displayName).toBe("Alice");
+  });
+
   test("Slack message without displayName omits the field", async () => {
     const ctx = createTestContext({
       userMessageChannel: "slack",

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

@@ -4,10 +4,10 @@
  *
  * Covers:
  *
- * 1. The eight default injectors registered by `defaultInjectorsPlugin` come
+ * 1. The nine default injectors registered by `defaultInjectorsPlugin` come
  *    back from `getInjectors()` in the documented order (workspace-context →
- *    unified-turn-context → pkb-context → pkb-reminder → now-md →
- *    subagent-status → slack-messages → thread-focus).
+ *    unified-turn-context → pkb-context → pkb-reminder → memory-v2-static →
+ *    now-md → subagent-status → slack-messages → thread-focus).
  * 2. A third-party-registered injector at `order: 25` slots between
  *    `unified-turn-context` (order 20) and `pkb` (order 30), proving the
  *    extensibility contract.
@@ -76,7 +76,7 @@ describe("injector chain", () => {
     resetPluginRegistryForTests();
   });
 
-  test("defaultInjectorsPlugin registers the eight defaults in the documented order", () => {
+  test("defaultInjectorsPlugin registers the nine defaults in the documented order", () => {
     registerPlugin(defaultInjectorsPlugin);
 
     const names = getInjectors().map((i) => i.name);
@@ -85,6 +85,7 @@ describe("injector chain", () => {
       "unified-turn-context",
       "pkb-context",
       "pkb-reminder",
+      "memory-v2-static",
       "now-md",
       "subagent-status",
       "slack-messages",
@@ -104,6 +105,9 @@ describe("injector chain", () => {
     );
     expect(byName.get("pkb-context")).toBe(DEFAULT_INJECTOR_ORDER.pkbContext);
     expect(byName.get("pkb-reminder")).toBe(DEFAULT_INJECTOR_ORDER.pkbReminder);
+    expect(byName.get("memory-v2-static")).toBe(
+      DEFAULT_INJECTOR_ORDER.memoryV2Static,
+    );
     expect(byName.get("now-md")).toBe(DEFAULT_INJECTOR_ORDER.nowMd);
     expect(byName.get("subagent-status")).toBe(
       DEFAULT_INJECTOR_ORDER.subagentStatus,
@@ -133,6 +137,7 @@ describe("injector chain", () => {
       "plugin-25", // 25 — slots in
       "pkb-context", // 30
       "pkb-reminder", // 35
+      "memory-v2-static", // 38
       "now-md", // 40
       "subagent-status", // 50
       "slack-messages", // 60
@@ -141,7 +146,7 @@ describe("injector chain", () => {
   });
 
   test("composeInjectorChain returns empty string when every injector opts out", async () => {
-    // The default chain is the golden-path: all eight defaults return `null`
+    // The default chain is the golden-path: all nine defaults return `null`
     // on an empty turn context, so the composed block is an empty string.
     registerPlugin(defaultInjectorsPlugin);