@vellumai/assistant 0.8.1 → 0.8.3

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

@@ -1,12 +1,16 @@
 /**
- * Tests for `preactivateHostProxySkills` and `shouldAttachHostProxyForCapability`
- * in `host-proxy-preactivation.ts`.
+ * Tests for `evaluateHostProxyAttachment`, `preactivateHostProxySkills`, and
+ * `shouldAttachHostProxyForCapability` in `host-proxy-preactivation.ts`.
  *
  * Covers:
  *  - Source interface natively supports capability → preactivate (regression)
  *  - Source interface doesn't support but capable client connected → preactivate
  *  - Source interface doesn't support and no capable client → don't preactivate
  *  - chrome-extension source + capable client connected → don't preactivate (security boundary)
+ *  - `evaluateHostProxyAttachment` returns the correct `reason` for each branch
+ *  - `preactivateHostProxySkills` emits one structured log line per call with
+ *    conversationId, sourceInterface, per-capability decisions, and final
+ *    preactivatedSkillIds (used by ATL-609-class silent-gate diagnosis)
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -26,31 +30,74 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
+// ---------------------------------------------------------------------------
+// Mock the logger so we can assert on the structured info call.
+// `info` calls are pushed into `loggedInfoCalls` for inspection.
+// `child()` is exposed for callers that wrap the logger that way.
+// ---------------------------------------------------------------------------
+
+interface LoggedCall {
+  fields: Record<string, unknown>;
+  message: string;
+}
+const loggedInfoCalls: LoggedCall[] = [];
+function captureInfo(fields: unknown, message: unknown) {
+  loggedInfoCalls.push({
+    fields: fields as Record<string, unknown>,
+    message: message as string,
+  });
+}
+
 mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  getLogger: () => ({
+    info: captureInfo,
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+    child: () => ({
+      info: captureInfo,
+      warn: () => {},
+      error: () => {},
+      debug: () => {},
+      trace: () => {},
+      fatal: () => {},
+    }),
+  }),
 }));
 
 // ---------------------------------------------------------------------------
-// Imports under test (after mocks are registered)
+// Imports under test
+//
+// Type-only imports are erased at runtime and safe to hoist. The value import
+// of `host-proxy-preactivation` must be dynamic (`await import`) so it
+// resolves AFTER the `mock.module(...)` calls above — otherwise ES module
+// hoisting loads the real logger before the mock registers, the production
+// `const log = getLogger(...)` binds to real pino, and assertions against
+// `loggedInfoCalls` see an empty array. Same pattern as
+// `secret-prompt-log-hygiene.test.ts`.
 // ---------------------------------------------------------------------------
 
 import type { HostProxyCapability } from "../channels/types.js";
-import {
-  type HostProxyPreactivationTarget,
+import type { HostProxyPreactivationTarget } from "../daemon/host-proxy-preactivation.js";
+
+const {
+  evaluateHostProxyAttachment,
   preactivateHostProxySkills,
   shouldAttachHostProxyForCapability,
-} from "../daemon/host-proxy-preactivation.js";
+} = await import("../daemon/host-proxy-preactivation.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeTarget(): HostProxyPreactivationTarget & {
-  preactivatedSkillIds: string[];
-} {
+function makeTarget(
+  conversationId = "conv-test",
+): HostProxyPreactivationTarget & { preactivatedSkillIds: string[] } {
   const preactivatedSkillIds: string[] = [];
   return {
+    conversationId,
     preactivatedSkillIds,
     addPreactivatedSkillId(id: string) {
       preactivatedSkillIds.push(id);
@@ -73,6 +120,7 @@ function setCapableClient(
 
 beforeEach(() => {
   mockClientsByCapability = new Map();
+  loggedInfoCalls.length = 0;
 });
 
 // ---------------------------------------------------------------------------
@@ -143,7 +191,10 @@ describe("shouldAttachHostProxyForCapability", () => {
     test("returns false for chrome-extension source even when a capable client is connected", () => {
       setCapableClient("host_app_control", true);
       expect(
-        shouldAttachHostProxyForCapability("host_app_control", "chrome-extension"),
+        shouldAttachHostProxyForCapability(
+          "host_app_control",
+          "chrome-extension",
+        ),
       ).toBe(false);
     });
   });
@@ -154,7 +205,7 @@ describe("shouldAttachHostProxyForCapability", () => {
 // ---------------------------------------------------------------------------
 
 describe("preactivateHostProxySkills", () => {
-  test("no-ops when sourceInterface is undefined", () => {
+  test("preactivates no skills when sourceInterface is undefined", () => {
     const target = makeTarget();
     preactivateHostProxySkills(target, undefined);
     expect(target.preactivatedSkillIds).toEqual([]);
@@ -209,3 +260,139 @@ describe("preactivateHostProxySkills", () => {
     expect(target.preactivatedSkillIds).toEqual([]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// evaluateHostProxyAttachment — reason coverage
+// ---------------------------------------------------------------------------
+
+describe("evaluateHostProxyAttachment", () => {
+  test("returns denied_no_interface when sourceInterface is undefined", () => {
+    expect(evaluateHostProxyAttachment("host_cu", undefined)).toEqual({
+      shouldAttach: false,
+      reason: "denied_no_interface",
+    });
+  });
+
+  test("returns native_support for macos + host_cu", () => {
+    expect(evaluateHostProxyAttachment("host_cu", "macos")).toEqual({
+      shouldAttach: true,
+      reason: "native_support",
+    });
+  });
+
+  test("returns denied_chrome_extension for chrome-extension source even when capable clients exist", () => {
+    setCapableClient("host_cu", true);
+    expect(evaluateHostProxyAttachment("host_cu", "chrome-extension")).toEqual({
+      shouldAttach: false,
+      reason: "denied_chrome_extension",
+    });
+  });
+
+  test("returns cross_client with clientCount when a capable client is connected", () => {
+    setCapableClient("host_cu", true);
+    expect(evaluateHostProxyAttachment("host_cu", "web")).toEqual({
+      shouldAttach: true,
+      reason: "cross_client",
+      clientCount: 1,
+    });
+  });
+
+  test("returns denied_no_clients with clientCount 0 when no capable client is connected", () => {
+    setCapableClient("host_cu", false);
+    expect(evaluateHostProxyAttachment("host_cu", "web")).toEqual({
+      shouldAttach: false,
+      reason: "denied_no_clients",
+      clientCount: 0,
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// preactivateHostProxySkills — structured logging
+// ---------------------------------------------------------------------------
+
+describe("preactivateHostProxySkills logging", () => {
+  test("emits exactly one info log per call", () => {
+    const target = makeTarget();
+    preactivateHostProxySkills(target, "macos");
+    expect(loggedInfoCalls).toHaveLength(1);
+    expect(loggedInfoCalls[0].message).toBe(
+      "host-proxy preactivation decision",
+    );
+  });
+
+  test("log includes conversationId, sourceInterface, per-capability decisions, and preactivatedSkillIds for macos", () => {
+    const target = makeTarget("conv-macos-123");
+    preactivateHostProxySkills(target, "macos");
+
+    expect(loggedInfoCalls).toHaveLength(1);
+    const { fields } = loggedInfoCalls[0];
+    expect(fields.conversationId).toBe("conv-macos-123");
+    expect(fields.sourceInterface).toBe("macos");
+    expect(fields.decisions).toEqual({
+      host_cu: { shouldAttach: true, reason: "native_support" },
+      host_app_control: { shouldAttach: true, reason: "native_support" },
+    });
+    expect(fields.preactivatedSkillIds).toEqual([
+      "computer-use",
+      "app-control",
+    ]);
+  });
+
+  test("log captures denied_no_interface for undefined sourceInterface (silent-gate diagnostic)", () => {
+    const target = makeTarget("conv-no-interface");
+    preactivateHostProxySkills(target, undefined);
+
+    expect(loggedInfoCalls).toHaveLength(1);
+    const { fields } = loggedInfoCalls[0];
+    expect(fields.conversationId).toBe("conv-no-interface");
+    expect(fields.sourceInterface).toBeUndefined();
+    expect(fields.decisions).toEqual({
+      host_cu: { shouldAttach: false, reason: "denied_no_interface" },
+      host_app_control: { shouldAttach: false, reason: "denied_no_interface" },
+    });
+    expect(fields.preactivatedSkillIds).toEqual([]);
+  });
+
+  test("log captures cross_client + clientCount when a web source has a connected host_cu client", () => {
+    setCapableClient("host_cu", true);
+    const target = makeTarget();
+    preactivateHostProxySkills(target, "web");
+
+    expect(loggedInfoCalls).toHaveLength(1);
+    const decisions = loggedInfoCalls[0].fields.decisions as Record<
+      string,
+      unknown
+    >;
+    expect(decisions.host_cu).toEqual({
+      shouldAttach: true,
+      reason: "cross_client",
+      clientCount: 1,
+    });
+    expect(decisions.host_app_control).toEqual({
+      shouldAttach: false,
+      reason: "denied_no_clients",
+      clientCount: 0,
+    });
+    expect(loggedInfoCalls[0].fields.preactivatedSkillIds).toEqual([
+      "computer-use",
+    ]);
+  });
+
+  test("log captures denied_chrome_extension reason for chrome-extension source", () => {
+    setCapableClient("host_cu", true);
+    const target = makeTarget();
+    preactivateHostProxySkills(target, "chrome-extension");
+
+    expect(loggedInfoCalls).toHaveLength(1);
+    const decisions = loggedInfoCalls[0].fields.decisions as Record<
+      string,
+      unknown
+    >;
+    expect(decisions.host_cu).toEqual({
+      shouldAttach: false,
+      reason: "denied_chrome_extension",
+    });
+    expect(loggedInfoCalls[0].fields.preactivatedSkillIds).toEqual([]);
+  });
+});

package/src/__tests__/image-credentials.test.ts

@@ -12,7 +12,7 @@ mock.module("../security/secure-keys.js", () => ({
   getProviderKeyAsync: async (_provider: string) => mockProviderKey,
 }));
 
-mock.module("../providers/managed-proxy/context.js", () => ({
+mock.module("../providers/platform-proxy/context.js", () => ({
   resolveManagedProxyContext: async () => ({
     enabled: !!mockPlatformBaseUrl && !!mockAssistantApiKey,
     platformBaseUrl: mockPlatformBaseUrl,

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

@@ -151,6 +151,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
           channelTs: "1700000001.111111",
           threadTs: "1700000000.000001",
           displayName: "Alice",
+          actorExternalUserId: "U_ALICE",
         },
       },
       undefined,
@@ -164,6 +165,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
     expect(slackMeta!.channelTs).toBe("1700000001.111111");
     expect(slackMeta!.threadTs).toBe("1700000000.000001");
     expect(slackMeta!.displayName).toBe("Alice");
+    expect(slackMeta!.actorExternalUserId).toBe("U_ALICE");
   });
 
   test("Slack top-level message: slackMeta has no threadTs", async () => {

package/src/__tests__/inference-no-mode-boot-e2e.test.ts

@@ -35,7 +35,7 @@ mock.module("../security/secure-keys.js", () => ({
 }));
 
 // Managed proxy context — always unavailable in this test (no platform auth).
-mock.module("../providers/managed-proxy/context.js", () => ({
+mock.module("../providers/platform-proxy/context.js", () => ({
   buildManagedBaseUrl: async () => null,
   resolveManagedProxyContext: async () => {
     throw new Error("managed proxy not available in test");

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

@@ -1,6 +1,7 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "./helpers/mock-logger.js";
+import { waitFor } from "./helpers/wait-for.js";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
@@ -86,8 +87,9 @@ describe("inference-profile-session-reaper", () => {
     });
 
     tickInferenceProfileReaper();
-    // Allow microtasks (promise callbacks) to settle
-    await Promise.resolve();
+    await waitFor(() => publishedEvents.length === 2, {
+      message: "Timed out waiting for inference profile reaper event",
+    });
 
     // Expired rows should be cleared
     expect(getConversation(conv1.id)?.inferenceProfile).toBeNull();

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

@@ -19,8 +19,10 @@ mock.module("../util/logger.js", () => ({
 // Stub the event hub so tests don't need a running event bus.
 // Exposed as a `mock(...)` so individual tests can assert publish calls.
 const publishMock = mock(async () => {});
+const broadcastMessageMock = mock(() => {});
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: { publish: publishMock },
+  broadcastMessage: broadcastMessageMock,
 }));
 
 // Stub buildAssistantEvent to be an identity pass-through for the event object
@@ -51,7 +53,10 @@ mock.module("../config/loader.js", () => ({
 // Real DB — same pattern as conversation-crud-inference-profile.test.ts
 // ---------------------------------------------------------------------------
 
-import { createConversation, getConversation } from "../memory/conversation-crud.js";
+import {
+  createConversation,
+  getConversation,
+} from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 
@@ -83,6 +88,7 @@ describe("setInferenceProfileSession", () => {
     mockProfiles = { balanced: {}, "cost-optimized": {} };
     mockMaxTtl = undefined; // reset to default 43200
     publishMock.mockClear();
+    broadcastMessageMock.mockClear();
   });
 
   test("open with ttlSeconds=600 — returns UUID sessionId and expiresAt ≈ now + 600_000", async () => {
@@ -139,7 +145,9 @@ describe("setInferenceProfileSession", () => {
     expect(result.ttlSeconds).toBe(43200);
     expect(result.expiresAt).not.toBeNull();
     expect(result.expiresAt!).toBeGreaterThanOrEqual(before + 43200 * 1000);
-    expect(result.expiresAt!).toBeLessThanOrEqual(Date.now() + 43200 * 1000 + 1000);
+    expect(result.expiresAt!).toBeLessThanOrEqual(
+      Date.now() + 43200 * 1000 + 1000,
+    );
   });
 
   test("open over active session — replaced carries prior session info", async () => {
@@ -208,6 +216,7 @@ describe("setInferenceProfileSession", () => {
     const updatedAtBefore = before?.updatedAt;
 
     publishMock.mockClear();
+    broadcastMessageMock.mockClear();
     const result = await setInferenceProfileSession({
       conversationId: conv.id,
       profile: null,
@@ -221,7 +230,7 @@ describe("setInferenceProfileSession", () => {
 
     // No event was published — this is the load-bearing assertion for the
     // idempotency guard (Codex P2 on PR #29913).
-    expect(publishMock).not.toHaveBeenCalled();
+    expect(broadcastMessageMock).not.toHaveBeenCalled();
 
     // No DB write occurred — `updatedAt` is unchanged.
     const after = getConversation(conv.id);
@@ -240,6 +249,7 @@ describe("setInferenceProfileSession", () => {
     });
 
     publishMock.mockClear();
+    broadcastMessageMock.mockClear();
     const result = await setInferenceProfileSession({
       conversationId: conv.id,
       profile: null,
@@ -250,8 +260,8 @@ describe("setInferenceProfileSession", () => {
     // though the sticky profile was cleared.
     expect(result.replaced).toBeNull();
 
-    // The clear DID happen — DB row reflects it and an event was published.
-    expect(publishMock).toHaveBeenCalledTimes(1);
+    // The clear DID happen — DB row reflects it and legacy+sync events were published.
+    expect(broadcastMessageMock).toHaveBeenCalledTimes(2);
     const row = getConversation(conv.id);
     expect(row?.inferenceProfile).toBeNull();
   });
@@ -265,7 +275,9 @@ describe("setInferenceProfileSession", () => {
         profile: "nonexistent-profile",
         ttlSeconds: 300,
       }),
-    ).rejects.toThrow('Profile "nonexistent-profile" is not defined in llm.profiles');
+    ).rejects.toThrow(
+      'Profile "nonexistent-profile" is not defined in llm.profiles',
+    );
   });
 
   test("open with ttlSeconds=null — expiresAt=null, sessionId=null, profile kept", async () => {

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

@@ -15,6 +15,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: { publish: async () => {} },
+  broadcastMessage: () => {},
 }));
 
 mock.module("../runtime/assistant-event.js", () => ({
@@ -43,9 +44,15 @@ import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
 
 initializeDb();
 
-const openRoute = ROUTES.find((r) => r.operationId === "inference_profile_open")!;
-const closeRoute = ROUTES.find((r) => r.operationId === "inference_profile_close")!;
-const listRoute = ROUTES.find((r) => r.operationId === "inference_profile_list")!;
+const openRoute = ROUTES.find(
+  (r) => r.operationId === "inference_profile_open",
+)!;
+const closeRoute = ROUTES.find(
+  (r) => r.operationId === "inference_profile_close",
+)!;
+const listRoute = ROUTES.find(
+  (r) => r.operationId === "inference_profile_list",
+)!;
 
 function clearTables(): void {
   const db = getDb();
@@ -77,7 +84,9 @@ describe("inference_profile_open IPC op", () => {
       replaced: null,
     });
     expect((result as { sessionId: string }).sessionId).not.toBeNull();
-    expect((result as { expiresAt: number }).expiresAt).toBeGreaterThan(Date.now());
+    expect((result as { expiresAt: number }).expiresAt).toBeGreaterThan(
+      Date.now(),
+    );
   });
 
   test("opens a sticky session (no ttlSeconds) — sessionId=null, expiresAt=null", async () => {
@@ -145,7 +154,10 @@ describe("inference_profile_close IPC op", () => {
     const result = (await closeRoute.handler({
       body: { conversationId: conv.id },
       headers: {},
-    })) as { noop: boolean; closed: { profile: string; sessionId: string } | null };
+    })) as {
+      noop: boolean;
+      closed: { profile: string; sessionId: string } | null;
+    };
 
     expect(result.noop).toBe(false);
     expect(result.closed).not.toBeNull();

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>",
+    );
+  });
+});