@vellumai/assistant 0.6.5 → 0.7.0

package/src/daemon/__tests__/conversation-feed-event.test.ts

@@ -0,0 +1,304 @@
+/**
+ * Tests for the background conversation feed event emission logic in
+ * conversation-agent-loop.ts.
+ *
+ * Rather than running the full agent loop, these tests exercise the
+ * extraction logic in isolation by simulating the conditions under which
+ * emitFeedEvent is called: conversation type, message content, and title.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module-level mocks — must be in place before importing the module under test
+// ---------------------------------------------------------------------------
+
+const emitFeedEventSpy = mock<
+  (params: {
+    source: string;
+    title: string;
+    summary: string;
+    dedupKey?: string;
+  }) => Promise<unknown>
+>(async () => ({}));
+
+mock.module("../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: emitFeedEventSpy,
+}));
+
+const getConversationSpy = mock<
+  (id: string) => {
+    conversationType: string;
+    title: string | null;
+  } | null
+>(() => null);
+
+const getMessageByIdSpy = mock<
+  (
+    messageId: string,
+    conversationId?: string,
+  ) => { id: string; content: string } | null
+>(() => null);
+
+// We need to stub enough of conversation-crud to avoid DB initialization.
+// The actual agent loop imports getConversation and getMessageById from
+// conversation-crud — we intercept those here for test assertions.
+mock.module("../../memory/conversation-crud.js", () => ({
+  getConversation: getConversationSpy,
+  getMessageById: getMessageByIdSpy,
+  // Stubs for other exports that may be transitively referenced:
+  addMessage: () => {},
+  clearStrippedInjectionMetadataForConversation: () => {},
+  deleteMessageById: () => {},
+  getConversationOriginChannel: () => null,
+  getConversationOriginInterface: () => null,
+  getLastUserTimestampBefore: () => null,
+  provenanceFromTrustContext: () => ({}),
+  updateConversationContextWindow: () => {},
+  updateConversationTitle: () => {},
+  updateMessageMetadata: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Simulates the feed-event emission logic from conversation-agent-loop.ts.
+ *
+ * This mirrors the block inserted after `message_complete` so we can test it
+ * in isolation without spinning up the full agent loop infrastructure.
+ */
+/**
+ * Tracks the last warning logged by simulateFeedEventEmission, so tests can
+ * assert that malformed content is swallowed gracefully.
+ */
+let lastFeedEventWarning: unknown = undefined;
+
+function simulateFeedEventEmission(
+  conversationId: string,
+  lastAssistantMessageId: string | undefined,
+): void {
+  lastFeedEventWarning = undefined;
+  try {
+    const conv = getConversationSpy(conversationId);
+    if (
+      conv &&
+      (conv.conversationType === "background" ||
+        conv.conversationType === "scheduled")
+    ) {
+      const lastMsg = lastAssistantMessageId
+        ? getMessageByIdSpy(lastAssistantMessageId, conversationId)
+        : undefined;
+      let summary: string;
+      if (lastMsg) {
+        const parsed: unknown = JSON.parse(lastMsg.content);
+        if (typeof parsed === "string") {
+          summary = parsed.slice(0, 200);
+        } else if (Array.isArray(parsed)) {
+          const textBlock = (
+            parsed as Array<{ type?: string; text?: string }>
+          ).find((b) => b.type === "text");
+          summary =
+            typeof textBlock?.text === "string"
+              ? textBlock.text.slice(0, 200)
+              : (conv.title ?? "Background task completed.");
+        } else {
+          summary = conv.title ?? "Background task completed.";
+        }
+      } else {
+        summary = conv.title ?? "Background task completed.";
+      }
+      void emitFeedEventSpy({
+        source: "assistant",
+        title: conv.title ?? "Background Task",
+        summary,
+        dedupKey: `bg-conv:${conversationId}`,
+      });
+    }
+  } catch (feedErr) {
+    lastFeedEventWarning = feedErr;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("background conversation feed event", () => {
+  beforeEach(() => {
+    emitFeedEventSpy.mockClear();
+    getConversationSpy.mockClear();
+    getMessageByIdSpy.mockClear();
+  });
+
+  afterEach(() => {
+    emitFeedEventSpy.mockReset();
+    getConversationSpy.mockReset();
+    getMessageByIdSpy.mockReset();
+  });
+
+  test("emits feed event for background conversation with text content", () => {
+    const convId = "conv-bg-123";
+    const msgId = "msg-456";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Nightly Cleanup",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([
+        { type: "text", text: "Cleaned up 42 files successfully." },
+      ]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy).toHaveBeenCalledWith({
+      source: "assistant",
+      title: "Nightly Cleanup",
+      summary: "Cleaned up 42 files successfully.",
+      dedupKey: `bg-conv:${convId}`,
+    });
+  });
+
+  test("emits feed event for scheduled conversation", () => {
+    const convId = "conv-sched-789";
+    const msgId = "msg-101";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "scheduled",
+      title: "Weekly Report",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "text", text: "Report generated." }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy).toHaveBeenCalledWith({
+      source: "assistant",
+      title: "Weekly Report",
+      summary: "Report generated.",
+      dedupKey: `bg-conv:${convId}`,
+    });
+  });
+
+  test("truncates summary to 200 characters", () => {
+    const convId = "conv-bg-long";
+    const msgId = "msg-long";
+    const longText = "A".repeat(300);
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Long Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "text", text: longText }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    const call = emitFeedEventSpy.mock.calls[0]![0];
+    expect(call.summary).toHaveLength(200);
+    expect(call.summary).toBe(longText.slice(0, 200));
+  });
+
+  test("falls back to conversation title when no text block in content", () => {
+    const convId = "conv-bg-notext";
+    const msgId = "msg-notext";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Image Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "image", source: { data: "..." } }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy.mock.calls[0]![0].summary).toBe("Image Task");
+  });
+
+  test("falls back to default summary when no message and no title", () => {
+    const convId = "conv-bg-notitle";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: null,
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    const call = emitFeedEventSpy.mock.calls[0]![0];
+    expect(call.title).toBe("Background Task");
+    expect(call.summary).toBe("Background task completed.");
+  });
+
+  test("does NOT emit feed event for standard (foreground) conversations", () => {
+    const convId = "conv-standard-1";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "standard",
+      title: "Regular Chat",
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+
+  test("uses dedupKey per conversation for in-place updates", () => {
+    const convId = "conv-bg-dedup";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Recurring Job",
+    });
+
+    // First run
+    simulateFeedEventEmission(convId, undefined);
+    // Second run (re-run of same conversation)
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(2);
+    // Both calls use the same dedupKey
+    expect(emitFeedEventSpy.mock.calls[0]![0].dedupKey).toBe(
+      `bg-conv:${convId}`,
+    );
+    expect(emitFeedEventSpy.mock.calls[1]![0].dedupKey).toBe(
+      `bg-conv:${convId}`,
+    );
+  });
+
+  test("swallows malformed JSON content without throwing", () => {
+    const convId = "conv-bg-badjson";
+    const msgId = "msg-badjson";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Bad JSON Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: "this is not valid JSON {{{",
+    });
+
+    // Should not throw
+    expect(() => simulateFeedEventEmission(convId, msgId)).not.toThrow();
+    // The error was caught and logged as a warning
+    expect(lastFeedEventWarning).toBeInstanceOf(SyntaxError);
+    // emitFeedEvent should NOT have been called
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+});

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -7,9 +7,9 @@
  * `auto-analyze` feature flag and source-type guard).
  *
  * We stub the downstream enqueue helpers and the side-effecting lifecycle
- * deps (hook manager, notifier/skill cleanup, browser-screencast) so the test
- * can invoke `disposeConversation` with a minimal `DisposeContext` and assert
- * on the enqueue bookkeeping alone.
+ * deps (notifier/skill cleanup, browser-screencast) so the test can invoke
+ * `disposeConversation` with a minimal `DisposeContext` and assert on the
+ * enqueue bookkeeping alone.
  *
  * Two recursion guards apply when the source conversation is itself an
  * auto-analysis conversation:
@@ -83,19 +83,12 @@ mock.module("../../memory/auto-analysis-enqueue.js", () => ({
 
 // Stub all side-effecting cleanup helpers that disposeConversation chains
 // into after the enqueue block. We assert on enqueue behavior only.
-mock.module("../../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: () => undefined,
-  }),
-}));
-
 mock.module("../../tools/browser/browser-screencast.js", () => ({
   unregisterConversationSender: () => {},
 }));
 
 mock.module("../conversation-notifiers.js", () => ({
   unregisterCallNotifiers: () => {},
-  unregisterWatchNotifiers: () => {},
 }));
 
 mock.module("../conversation-skill-tools.js", () => ({
@@ -105,8 +98,7 @@ mock.module("../conversation-skill-tools.js", () => ({
 // Dynamic import after mock.module calls so stubs take effect.
 const { disposeConversation } = await import("../conversation-lifecycle.js");
 type DisposeContext = import("../conversation-lifecycle.js").DisposeContext;
-type TrustClass =
-  import("../../runtime/actor-trust-resolver.js").TrustClass;
+type TrustClass = import("../../runtime/actor-trust-resolver.js").TrustClass;
 
 // ---------------------------------------------------------------------------
 // Fixture builder — minimal DisposeContext satisfying the interface shape.

package/src/daemon/__tests__/conversation-surfaces-launch.test.ts

@@ -84,7 +84,7 @@ const { registerLaunchConversationDeps, resetLaunchConversationDeps } =
   await import("../conversation-launch.js");
 type SurfaceConversationContext =
   import("../conversation-surfaces.js").SurfaceConversationContext;
-type TrustContext = import("../conversation-runtime-assembly.js").TrustContext;
+type TrustContext = import("../trust-context.js").TrustContext;
 type ServerMessage = import("../message-protocol.js").ServerMessage;
 type SurfaceData = import("../message-protocol.js").SurfaceData;
 type SurfaceType = import("../message-protocol.js").SurfaceType;

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -8,16 +8,16 @@
  *   run with `hasNoClient: true` because chrome-extension is not in
  *   `INTERACTIVE_INTERFACES`).
  * - macos requires a connected SSE client for host tools that flow through
- *   the proxy (e.g. host_bash, host_file_*), so `hasNoClient: true` denies
- *   those on macos.
- * - host_browser is NOT in the macos capability set because the proxy path
- *   requires a Chrome extension that isn't guaranteed to be attached; macos
- *   browser tools fall back to local Playwright Chromium.
+ *   the proxy (e.g. host_bash, host_file_*, host_browser), so
+ *   `hasNoClient: true` denies those on macos.
+ * - host_browser IS in the macos capability set — the proxy routes
+ *   host_browser_request frames to the desktop client via SSE (or via the
+ *   Chrome extension registry when an extension connection is present).
  *
  * The per-capability check (`supportsHostProxy(transport, capability)`) runs
  * first and is authoritative for structural support, so host_bash and
  * host_file_* are filtered out for chrome-extension regardless of the
- * hasNoClient flag, and host_browser is filtered out for macos.
+ * hasNoClient flag.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -74,23 +74,22 @@ describe("isToolActiveForContext — host tool capability gating", () => {
     ).toBe(false);
   });
 
-  test("host_browser is NOT active for macOS (uses local Playwright)", () => {
-    // host_browser is not in the macos capability set because the proxy path
-    // requires a Chrome extension that isn't guaranteed to be attached; macos
-    // browser tools fall back to local Playwright Chromium instead. The
-    // per-capability check is authoritative, so host_browser is filtered out
-    // for macos regardless of client connection state.
+  test("host_browser is active for macOS with a connected client", () => {
+    // macOS supports host_browser — the proxy routes host_browser_request
+    // frames to the desktop client via SSE (or via the Chrome extension
+    // registry when an extension connection is present).
     expect(
       isToolActiveForContext(
         "host_browser",
         makeCtx({ hasNoClient: false, transportInterface: "macos" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 
   test("host_browser is NOT active for macOS when hasNoClient is true", () => {
-    // Same capability gate as above: host_browser is unsupported on macos
-    // regardless of connection state.
+    // macOS supports host_browser structurally, but without a connected
+    // client the host_browser_request frames have no consumer, so the tool
+    // is denied.
     expect(
       isToolActiveForContext(
         "host_browser",

package/src/daemon/__tests__/daemon-skill-host.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Smoke test for `createDaemonSkillHost`.
+ *
+ * The goal here is narrow: construct the host with a stub skillId and
+ * shallow-assert that every facet and method lines up with the
+ * `SkillHost` contract. We stub every delegate module with `mock.module`
+ * so the test neither touches real singletons (config loader, event hub,
+ * SQLite, provider registries) nor requires workspace initialization.
+ *
+ * Deep behavioral coverage for each delegate lives in that delegate's own
+ * test — this file is just a wiring check.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module-level stubs — installed before importing the module under test
+// ---------------------------------------------------------------------------
+
+const loggerSpy = {
+  debug: mock(() => {}),
+  info: mock(() => {}),
+  warn: mock(() => {}),
+  error: mock(() => {}),
+};
+mock.module("../../util/logger.js", () => ({
+  getLogger: () => loggerSpy,
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    services: { tts: { provider: "elevenlabs" }, nested: { value: 42 } },
+  }),
+  getNestedValue: (obj: Record<string, unknown>, path: string) => {
+    const keys = path.split(".");
+    let cur: unknown = obj;
+    for (const k of keys) {
+      if (cur == null || typeof cur !== "object") return undefined;
+      cur = (cur as Record<string, unknown>)[k];
+    }
+    return cur;
+  },
+}));
+
+mock.module("../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) => key === "enabled-flag",
+}));
+
+mock.module("../identity-helpers.js", () => ({
+  // Default returns null so we can assert normalization to undefined.
+  getAssistantName: () => null,
+}));
+
+mock.module("../../util/platform.js", () => ({
+  getWorkspaceDir: () => "/tmp/workspace",
+  vellumRoot: () => "/tmp/vellum",
+}));
+
+mock.module("../../runtime/runtime-mode.js", () => ({
+  getDaemonRuntimeMode: () => "bare-metal",
+}));
+
+mock.module("../../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: async () => ({ id: "stub-provider" }),
+  userMessage: (text: string) => ({ role: "user", content: text }),
+  extractToolUse: () => undefined,
+  createTimeout: () => ({
+    signal: new AbortController().signal,
+    cleanup: () => {},
+  }),
+}));
+
+mock.module("../../providers/speech-to-text/provider-catalog.js", () => ({
+  listProviderIds: () => ["whisper"],
+  supportsBoundary: () => true,
+}));
+
+mock.module("../../providers/speech-to-text/resolve.js", () => ({
+  resolveStreamingTranscriber: async () => ({ kind: "stream" }),
+}));
+
+mock.module("../../tts/provider-registry.js", () => ({
+  getTtsProvider: (id: string) => ({ id }),
+}));
+
+mock.module("../../tts/tts-config-resolver.js", () => ({
+  resolveTtsConfig: () => ({ provider: "elevenlabs" }),
+}));
+
+mock.module("../../security/secure-keys.js", () => ({
+  // Default returns undefined so we can assert normalization to null.
+  getProviderKeyAsync: async () => undefined,
+}));
+
+mock.module("../../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "msg-123" }),
+}));
+
+mock.module("../../runtime/agent-wake.js", () => ({
+  wakeAgentForOpportunity: async () => ({ invoked: true }),
+}));
+
+const publishSpy = mock(async () => {});
+const subscribeSpy = mock(() => ({ dispose: () => {}, active: true }));
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: publishSpy,
+    subscribe: subscribeSpy,
+  },
+}));
+
+mock.module("../../runtime/assistant-event.js", () => ({
+  buildAssistantEvent: (
+    assistantId: string,
+    message: unknown,
+    conversationId?: string,
+  ) => ({
+    id: "evt-1",
+    assistantId,
+    conversationId,
+    emittedAt: "2024-01-01T00:00:00.000Z",
+    message,
+  }),
+}));
+
+mock.module("../../runtime/assistant-scope.js", () => ({
+  DAEMON_INTERNAL_ASSISTANT_ID: "self",
+}));
+
+const registerExternalToolsSpy = mock(() => {});
+mock.module("../../tools/registry.js", () => ({
+  registerExternalTools: registerExternalToolsSpy,
+}));
+
+const registerSkillRouteSpy = mock(() => Object.freeze({}));
+mock.module("../../runtime/skill-route-registry.js", () => ({
+  registerSkillRoute: registerSkillRouteSpy,
+}));
+
+const registerShutdownHookSpy = mock(() => {});
+mock.module("../shutdown-registry.js", () => ({
+  registerShutdownHook: registerShutdownHookSpy,
+}));
+
+class StubSpeakerTracker {}
+mock.module("../../calls/speaker-identification.js", () => ({
+  SpeakerIdentityTracker: StubSpeakerTracker,
+}));
+
+// ---------------------------------------------------------------------------
+// Module under test — imported after every stub is in place
+// ---------------------------------------------------------------------------
+
+import { createDaemonSkillHost } from "../daemon-skill-host.js";
+
+describe("createDaemonSkillHost", () => {
+  const host = createDaemonSkillHost("meet-join");
+
+  test("exposes every facet", () => {
+    expect(host.logger).toBeDefined();
+    expect(host.config).toBeDefined();
+    expect(host.identity).toBeDefined();
+    expect(host.platform).toBeDefined();
+    expect(host.providers).toBeDefined();
+    expect(host.memory).toBeDefined();
+    expect(host.events).toBeDefined();
+    expect(host.registries).toBeDefined();
+    expect(host.speakers).toBeDefined();
+  });
+
+  test("logger.get returns an object with the four severity methods", () => {
+    const log = host.logger.get("test-scope");
+    log.debug("d", { k: "v" });
+    log.info("i");
+    log.warn("w");
+    log.error("e");
+    expect(loggerSpy.debug).toHaveBeenCalled();
+    expect(loggerSpy.info).toHaveBeenCalled();
+    expect(loggerSpy.warn).toHaveBeenCalled();
+    expect(loggerSpy.error).toHaveBeenCalled();
+  });
+
+  test("config.isFeatureFlagEnabled delegates to the feature-flag helper", () => {
+    expect(host.config.isFeatureFlagEnabled("enabled-flag")).toBe(true);
+    expect(host.config.isFeatureFlagEnabled("other-flag")).toBe(false);
+  });
+
+  test("config.getSection walks dotted paths into the resolved config", () => {
+    expect(
+      host.config.getSection<{ provider: string }>("services.tts"),
+    ).toEqual({ provider: "elevenlabs" });
+    expect(host.config.getSection<number>("services.nested.value")).toBe(42);
+    expect(host.config.getSection("services.missing.path")).toBeUndefined();
+  });
+
+  test("identity normalizes a null assistant name to undefined", () => {
+    expect(host.identity.getAssistantName()).toBeUndefined();
+    expect(host.identity.internalAssistantId).toBe("self");
+  });
+
+  test("platform methods return the stubbed values", () => {
+    expect(host.platform.workspaceDir()).toBe("/tmp/workspace");
+    expect(host.platform.vellumRoot()).toBe("/tmp/vellum");
+    expect(host.platform.runtimeMode()).toBe("bare-metal");
+  });
+
+  test("providers.stt lists ids and answers boundary questions", () => {
+    expect(host.providers.stt.listProviderIds()).toEqual(["whisper"]);
+    expect(host.providers.stt.supportsBoundary("whisper")).toBe(true);
+  });
+
+  test("providers.tts exposes get + resolveConfig", () => {
+    expect(host.providers.tts.get("elevenlabs")).toEqual({ id: "elevenlabs" });
+    expect(host.providers.tts.resolveConfig()).toEqual({
+      provider: "elevenlabs",
+    });
+  });
+
+  test("providers.secureKeys normalizes undefined to null", async () => {
+    await expect(
+      host.providers.secureKeys.getProviderKey("x"),
+    ).resolves.toBeNull();
+  });
+
+  test("providers.llm exposes the four message helpers", () => {
+    expect(typeof host.providers.llm.getConfigured).toBe("function");
+    expect(typeof host.providers.llm.userMessage).toBe("function");
+    expect(typeof host.providers.llm.extractToolUse).toBe("function");
+    const { signal, cleanup } = host.providers.llm.createTimeout(1000);
+    expect(signal).toBeInstanceOf(AbortSignal);
+    expect(typeof cleanup).toBe("function");
+    cleanup();
+  });
+
+  test("memory.addMessage and wakeAgentForOpportunity are callable", async () => {
+    await expect(
+      host.memory.addMessage("c1", "user", "hi"),
+    ).resolves.toBeDefined();
+    await expect(
+      host.memory.wakeAgentForOpportunity({ conversationId: "c1" }),
+    ).resolves.toBeUndefined();
+  });
+
+  test("events.publish, subscribe, and buildEvent plumb through the hub", async () => {
+    const evt = host.events.buildEvent({ type: "ping" }, "c1");
+    expect(evt.assistantId).toBe("self");
+    expect(evt.conversationId).toBe("c1");
+    await host.events.publish(evt);
+    expect(publishSpy).toHaveBeenCalled();
+    const sub = host.events.subscribe({ assistantId: "self" }, () => undefined);
+    expect(sub.active).toBe(true);
+    expect(subscribeSpy).toHaveBeenCalled();
+  });
+
+  test("registries expose the three registration methods", () => {
+    host.registries.registerTools(() => []);
+    expect(registerExternalToolsSpy).toHaveBeenCalled();
+    const handle = host.registries.registerSkillRoute({
+      pattern: /^\/foo/,
+      methods: ["GET"],
+      handler: async () => new Response("ok"),
+    });
+    expect(handle).toBeDefined();
+    expect(registerSkillRouteSpy).toHaveBeenCalled();
+    host.registries.registerShutdownHook("test-hook", async () => {});
+    expect(registerShutdownHookSpy).toHaveBeenCalled();
+  });
+
+  test("speakers.createTracker yields a concrete tracker instance", () => {
+    expect(host.speakers.createTracker()).toBeInstanceOf(StubSpeakerTracker);
+  });
+});