@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/external-plugin-loader.test.ts

@@ -0,0 +1,458 @@
+/**
+ * Tests for the external plugin loader.
+ *
+ * The loader now owns the timeout / try-catch / `registerPlugin` triple
+ * directly, so tests exercise observable behavior: after
+ * `await loadExternalPlugin(dir)`, what does the registry hold?
+ *
+ * Each test materializes a synthetic plugin directory under a per-file
+ * tempdir. Surface files use plain TypeScript with default exports so
+ * bun can dynamic-import them at runtime without a build step.
+ */
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import { loadExternalPlugin } from "../plugins/external-plugin-loader.js";
+import {
+  getRegisteredPlugins,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+
+const ROOT = join(
+  tmpdir(),
+  `vellum-external-plugin-loader-test-${process.pid}-${Date.now()}`,
+);
+
+function freshPluginDir(name: string): string {
+  const dir = join(ROOT, name);
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function writePackageJson(dir: string, pkg: Record<string, unknown>): void {
+  writeFileSync(join(dir, "package.json"), JSON.stringify(pkg, null, 2));
+}
+
+function writeSurfaceFile(dir: string, relPath: string, body: string): void {
+  const parts = relPath.split("/");
+  parts.pop();
+  if (parts.length > 0) {
+    mkdirSync(join(dir, ...parts), { recursive: true });
+  }
+  writeFileSync(join(dir, relPath), body);
+}
+
+function registeredNames(): string[] {
+  return getRegisteredPlugins().map((p) => p.manifest.name);
+}
+
+beforeEach(() => {
+  resetPluginRegistryForTests();
+});
+
+afterAll(() => {
+  rmSync(ROOT, { recursive: true, force: true });
+  resetPluginRegistryForTests();
+});
+
+describe("loadExternalPlugin — manifest", () => {
+  test("uses package.json name and version", async () => {
+    const dir = freshPluginDir("minimal");
+    writePackageJson(dir, { name: "minimal-plugin", version: "1.2.3" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "minimal-plugin",
+    );
+    expect(registered).toBeDefined();
+    expect(registered?.manifest.version).toBe("1.2.3");
+    // Defaults to pluginRuntime v1 when no `vellum.requires` is set.
+    expect(registered?.manifest.requires).toEqual({ pluginRuntime: "v1" });
+  });
+
+  test("strips npm scope from name", async () => {
+    const dir = freshPluginDir("scoped");
+    writePackageJson(dir, {
+      name: "@vellumai/simple-memory",
+      version: "0.1.0",
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("simple-memory");
+  });
+
+  test("defaults version to 0.0.0 when package.json omits it", async () => {
+    const dir = freshPluginDir("no-version");
+    writePackageJson(dir, { name: "no-version-plugin" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "no-version-plugin",
+    );
+    expect(registered?.manifest.version).toBe("0.0.0");
+  });
+
+  test("reads vellum.requires from package.json when present", async () => {
+    // Future direction (out of scope this PR): `requires` may carry
+    // `assistantVersion` alongside `pluginRuntime`. For today the registry
+    // validates against `ASSISTANT_API_VERSIONS` and only `pluginRuntime`
+    // is a known capability — so the loader's pass-through behavior is
+    // exercised with the keys the registry already accepts. The loader is
+    // opaque to the shape; additional keys propagate identically.
+    const dir = freshPluginDir("custom-requires");
+    writePackageJson(dir, {
+      name: "custom-requires",
+      version: "0.1.0",
+      vellum: { requires: { pluginRuntime: "v1" } },
+    });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "custom-requires",
+    );
+    expect(registered?.manifest.requires).toEqual({ pluginRuntime: "v1" });
+  });
+
+  test("vellum.requires overrides the default — empty requires fails registration", async () => {
+    // Belt-and-suspenders proof that the loader reads `vellum.requires`
+    // rather than always defaulting: an empty `vellum.requires` propagates
+    // through, the registry rejects the plugin (missing pluginRuntime),
+    // and the registry stays empty.
+    const dir = freshPluginDir("empty-requires");
+    writePackageJson(dir, {
+      name: "empty-requires",
+      version: "0.1.0",
+      vellum: { requires: {} },
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).not.toContain("empty-requires");
+  });
+
+  test("does not synthesize a provides field", async () => {
+    const dir = freshPluginDir("no-provides");
+    writePackageJson(dir, { name: "no-provides", version: "0.1.0" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "no-provides",
+    );
+    expect(registered?.manifest.provides).toBeUndefined();
+  });
+
+  test("malformed package.json is logged and skipped (registry untouched)", async () => {
+    const dir = freshPluginDir("malformed-pkg");
+    writeFileSync(join(dir, "package.json"), "{ this is not json");
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("package.json missing name is logged and skipped", async () => {
+    const dir = freshPluginDir("no-name");
+    writePackageJson(dir, { version: "1.0.0" });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("empty string name is logged and skipped", async () => {
+    const dir = freshPluginDir("empty-name");
+    writePackageJson(dir, { name: "", version: "1.0.0" });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+});
+
+describe("loadExternalPlugin — hooks", () => {
+  test("wires hooks/init.ts default export to plugin.hooks.init", async () => {
+    const dir = freshPluginDir("with-init");
+    writePackageJson(dir, { name: "with-init", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `export default async function init(_ctx: unknown): Promise<void> {
+  (globalThis as Record<string, unknown>).__externalInitCalled = true;
+}
+`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "with-init",
+    );
+    expect(typeof registered?.hooks?.init).toBe("function");
+    await registered?.hooks?.init?.({} as never);
+    expect(
+      (globalThis as Record<string, unknown>).__externalInitCalled,
+    ).toBe(true);
+    delete (globalThis as Record<string, unknown>).__externalInitCalled;
+  });
+
+  test("wires hooks/shutdown.ts default export to plugin.hooks.shutdown", async () => {
+    const dir = freshPluginDir("with-shutdown");
+    writePackageJson(dir, { name: "with-shutdown", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/shutdown.ts",
+      `export default async function shutdown(ctx: { assistantVersion: string }): Promise<void> {
+  (globalThis as Record<string, unknown>).__externalShutdownCalled = true;
+  (globalThis as Record<string, unknown>).__externalShutdownVersion =
+    ctx.assistantVersion;
+}
+`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "with-shutdown",
+    );
+    expect(typeof registered?.hooks?.shutdown).toBe("function");
+    await registered?.hooks?.shutdown?.({ assistantVersion: "9.9.9-test" });
+    expect(
+      (globalThis as Record<string, unknown>).__externalShutdownCalled,
+    ).toBe(true);
+    expect(
+      (globalThis as Record<string, unknown>).__externalShutdownVersion,
+    ).toBe("9.9.9-test");
+    delete (globalThis as Record<string, unknown>).__externalShutdownCalled;
+    delete (globalThis as Record<string, unknown>).__externalShutdownVersion;
+  });
+
+  test("ignores hooks/*.d.ts declaration files alongside hooks/*.js", async () => {
+    // Compiled plugins ship `init.js` + `init.d.ts` side-by-side. The walker
+    // must filter the declaration files out — they have no default-exported
+    // runtime function, and crashing `importDefault` would skip the plugin
+    // wholesale. Regression guard for the .d.ts ingest bug fixed in this PR.
+    const dir = freshPluginDir("with-dts");
+    writePackageJson(dir, { name: "with-dts", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.js",
+      `export default async function init(_ctx) {
+  (globalThis).__externalDtsInitCalled = true;
+}
+`,
+    );
+    writeSurfaceFile(
+      dir,
+      "hooks/init.d.ts",
+      `export default function init(ctx: unknown): Promise<void>;\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "with-dts",
+    );
+    expect(registered).toBeDefined();
+    expect(Object.keys(registered?.hooks ?? {})).toEqual(["init"]);
+    expect(typeof registered?.hooks?.init).toBe("function");
+    await registered?.hooks?.init?.({} as never);
+    expect((globalThis as Record<string, unknown>).__externalDtsInitCalled).toBe(
+      true,
+    );
+    delete (globalThis as Record<string, unknown>).__externalDtsInitCalled;
+  });
+
+  test("plugin.hooks is undefined when neither hook file is present", async () => {
+    const dir = freshPluginDir("no-hooks");
+    writePackageJson(dir, { name: "no-hooks", version: "0.1.0" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "no-hooks",
+    );
+    expect(registered?.hooks).toBeUndefined();
+  });
+
+  test("hooks/init.ts with no default export is logged and skipped", async () => {
+    const dir = freshPluginDir("init-no-default");
+    writePackageJson(dir, { name: "init-no-default", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `export const init = async () => undefined;\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("hooks/init.ts default export not a function is logged and skipped", async () => {
+    const dir = freshPluginDir("init-not-fn");
+    writePackageJson(dir, { name: "init-not-fn", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `export default { not: "a function" };\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+});
+
+describe("loadExternalPlugin — tools", () => {
+  test("collects every default-exported tool under tools/", async () => {
+    const dir = freshPluginDir("two-tools");
+    writePackageJson(dir, { name: "two-tools", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "tools/alpha.ts",
+      `export default {
+  name: "two_tools_alpha",
+  description: "alpha",
+  category: "plugin",
+  defaultRiskLevel: "low" as const,
+  getDefinition() { return { name: "two_tools_alpha", description: "alpha", input_schema: { type: "object", properties: {}, required: [] } }; },
+  async execute() { return { content: "a", isError: false }; },
+};
+`,
+    );
+    writeSurfaceFile(
+      dir,
+      "tools/beta.ts",
+      `export default {
+  name: "two_tools_beta",
+  description: "beta",
+  category: "plugin",
+  defaultRiskLevel: "low" as const,
+  getDefinition() { return { name: "two_tools_beta", description: "beta", input_schema: { type: "object", properties: {}, required: [] } }; },
+  async execute() { return { content: "b", isError: false }; },
+};
+`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "two-tools",
+    );
+    const names = (registered?.tools ?? []).map(
+      (t) => (t as { name: string }).name,
+    );
+    expect(names).toEqual(["two_tools_alpha", "two_tools_beta"]);
+  });
+
+  test("plugin.tools is undefined when tools/ is absent", async () => {
+    const dir = freshPluginDir("no-tools");
+    writePackageJson(dir, { name: "no-tools", version: "0.1.0" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "no-tools",
+    );
+    expect(registered?.tools).toBeUndefined();
+  });
+
+  test("a tool file with no default export is logged and skipped", async () => {
+    const dir = freshPluginDir("tool-no-default");
+    writePackageJson(dir, { name: "tool-no-default", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "tools/broken.ts",
+      `export const broken = { name: "broken" };\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("a tool default export missing string name is logged and skipped", async () => {
+    const dir = freshPluginDir("tool-no-name");
+    writePackageJson(dir, { name: "tool-no-name", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "tools/nameless.ts",
+      `export default { description: "missing name" };\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+});
+
+describe("loadExternalPlugin — isolation", () => {
+  test("never throws when a load fails — error is logged and skipped", async () => {
+    const dir = freshPluginDir("definitely-broken");
+    writeFileSync(join(dir, "package.json"), "{ broken");
+
+    await expect(loadExternalPlugin(dir)).resolves.toBeUndefined();
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("times out and skips when build exceeds the timeout", async () => {
+    // hooks/init.ts has a top-level await that never resolves. The build
+    // hangs on dynamic-importing this surface file; the loader's timeout
+    // must rescue the daemon boot.
+    const dir = freshPluginDir("hanging-init");
+    writePackageJson(dir, { name: "hanging-init", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `await new Promise(() => {});
+export default async function init(_ctx: unknown): Promise<void> {}
+`,
+    );
+
+    await loadExternalPlugin(dir, { importTimeoutMs: 50 });
+
+    expect(registeredNames()).not.toContain("hanging-init");
+  });
+});
+
+describe("loadExternalPlugin — end-to-end @vellumai/simple-memory", () => {
+  test("loads the in-tree simple-memory plugin", async () => {
+    // Resolve the real on-disk plugin from the worktree. This double-acts
+    // as the loader's contract test against the canonical Phase 0 plugin
+    // and exercises the relative `../src/state.js` imports inside the
+    // plugin's surface files.
+    const pluginDir = join(
+      import.meta.dir,
+      "..",
+      "..",
+      "..",
+      "experimental",
+      "plugins",
+      "simple-memory",
+    );
+
+    await loadExternalPlugin(pluginDir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "simple-memory",
+    );
+    expect(registered).toBeDefined();
+    expect(typeof registered?.hooks?.init).toBe("function");
+    expect(typeof registered?.hooks?.shutdown).toBe("function");
+    const toolNames = (registered?.tools ?? [])
+      .map((t) => (t as { name: string }).name)
+      .sort();
+    expect(toolNames).toEqual([
+      "simple_memory_recall",
+      "simple_memory_remember",
+    ]);
+  });
+});

package/src/__tests__/filing-service.test.ts

@@ -7,6 +7,13 @@ import { LLMSchema } from "../config/schemas/llm.js";
 
 const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 
+// Default the warm-pool gate to OPEN for existing tests — they predate
+// the gate and expect filing's runOnce() to fire on every tick.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 // Mock config loader. Filing's `runOnce()` reads `getConfig().filing`, and
 // `executeRun()` no longer reads `config.speed` (PR 8) — the call site is
 // hardcoded to 'filingAgent' and the resolver picks up `llm.callSites.filingAgent`
@@ -35,8 +42,12 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // Mock conversation store
-const createdConversations: Array<{ title: string; conversationType: string }> =
-  [];
+const createdConversations: Array<{
+  title: string;
+  conversationType: string;
+  source?: string;
+  groupId?: string;
+}> = [];
 let conversationIdCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
@@ -63,7 +74,12 @@ mock.module("../memory/conversation-crud.js", () => ({
   }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
-  createConversation: (opts: { title: string; conversationType: string }) => {
+  createConversation: (opts: {
+    title: string;
+    conversationType: string;
+    source?: string;
+    groupId?: string;
+  }) => {
     createdConversations.push(opts);
     return { id: `conv-${++conversationIdCounter}`, ...opts };
   },
@@ -220,6 +236,10 @@ describe("FilingService", () => {
     expect(createdConversations).toHaveLength(1);
     expect(createdConversations[0].title).toBe("Generating title...");
     expect(createdConversations[0].conversationType).toBe("background");
+    // Confirms FilingService routes through runBackgroundJob:
+    //   source="filing" + runner-default groupId="system:background".
+    expect(createdConversations[0].source).toBe("filing");
+    expect(createdConversations[0].groupId).toBe("system:background");
   });
 
   describe("runCompactionOnce()", () => {

package/src/__tests__/fixtures/mock-chrome-extension.ts

@@ -224,6 +224,11 @@ export function createMockChromeExtension(
         headers: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${options.token}`,
+          // Same-actor binding: identifies this fixture to the daemon's
+          // result-route check. The daemon will reject targeted host_browser
+          // results without this header (or where it doesn't match the
+          // captured target client).
+          "X-Vellum-Client-Id": clientId,
         },
         body: JSON.stringify(body),
       });

package/src/__tests__/gateway-only-guard.test.ts

@@ -34,7 +34,6 @@ const ALLOWLIST = new Set([
 
   // --- Chrome extension (local relay communication, not gateway API consumption) ---
   "clients/chrome-extension/background/worker.ts",
-  "clients/chrome-extension/popup/popup.ts",
   // --- Documentation and comments that mention the port for explanatory purposes ---
   "AGENTS.md", // documents the gateway-only rule itself
   "ARCHITECTURE.md", // architecture overview with port references

package/src/__tests__/graph-extraction-event-date.test.ts

@@ -191,6 +191,40 @@ describe("parseExtractionResponse event_date coercion", () => {
     expect(diff.updateNodes[0].changes.eventDate).toBe(1712534400000);
   });
 
+  test("auto-creates an event trigger for future event_date", () => {
+    const conversationTs = Date.UTC(2026, 3, 26, 0, 0, 0);
+    const futureEventDate = Date.UTC(2026, 5, 1, 0, 0, 0);
+    const input = makeInput({ event_date: futureEventDate });
+    const { deferredTriggers } = parseExtractionResponse(
+      input,
+      conversationId,
+      scopeId,
+      candidateNodeIds,
+      conversationTs,
+    );
+    const auto = deferredTriggers.find(
+      (t) =>
+        t.trigger.type === "event" && t.trigger.eventDate === futureEventDate,
+    );
+    expect(auto).toBeTruthy();
+  });
+
+  test("does not auto-create an event trigger for past event_date", () => {
+    const conversationTs = Date.UTC(2026, 3, 26, 0, 0, 0);
+    const pastEventDate = Date.UTC(2025, 0, 15, 0, 0, 0);
+    const input = makeInput({ event_date: pastEventDate });
+    const { deferredTriggers } = parseExtractionResponse(
+      input,
+      conversationId,
+      scopeId,
+      candidateNodeIds,
+      conversationTs,
+    );
+    expect(deferredTriggers.some((t) => t.trigger.type === "event")).toBe(
+      false,
+    );
+  });
+
   test("null-clears event_date on update_nodes when explicitly null", () => {
     const existingNodeId = "existing-node-1";
     const candidates = new Set([existingNodeId]);

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -245,12 +245,4 @@ describe("v2 skill re-seed gating in skill handlers", () => {
     expect(mockMaybeSeedMemoryV2Skills).toHaveBeenCalledTimes(1);
     expect(callOrder).toEqual(["v1"]);
   });
-
-  // Note: "seed rejection swallowed" is now an internal concern of
-  // `maybeSeedMemoryV2Skills` — it dispatches the seed call as a
-  // fire-and-forget promise with `.catch(log.warn)`. That behavior is
-  // covered by `lifecycle-memory-v2-seed.test.ts`. From the handler's
-  // perspective, we only need to verify the helper is invoked
-  // synchronously with the correct config — which the cases above already
-  // exercise.
 });

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -1,5 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+// Default the warm-pool gate to OPEN — these tests probe disk-pressure
+// behavior, not the pre-first-message guard.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -63,6 +70,10 @@ mock.module("../memory/conversation-crud.js", () => ({
     createdConversations.push(opts);
     return { id: "conv-1", ...opts };
   },
+  // runBackgroundJob (loaded transitively via heartbeat-service) imports
+  // addMessage. Disk-pressure short-circuits before addMessage ever runs,
+  // but the mock module must still expose every name the real module does.
+  addMessage: () => Promise.resolve({ id: "mock-msg-id" }),
 }));
 
 const mockProcessMessage = mock(() => Promise.resolve({ messageId: "msg-1" }));
@@ -70,9 +81,11 @@ mock.module("../daemon/process-message.js", () => ({
   processMessage: mockProcessMessage,
 }));
 
-const mockEmitFeedEvent = mock(() => Promise.resolve());
-mock.module("../home/emit-feed-event.js", () => ({
-  emitFeedEvent: mockEmitFeedEvent,
+const emittedNotificationSignals: Array<{ sourceEventName?: string }> = [];
+mock.module("../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (opts: { sourceEventName?: string }) => {
+    emittedNotificationSignals.push({ sourceEventName: opts.sourceEventName });
+  },
 }));
 
 mock.module("../prompts/persona-resolver.js", () => ({
@@ -131,10 +144,10 @@ describe("HeartbeatService disk pressure gate", () => {
     mockMarkStaleRunningAsError.mockClear();
     mockMarkStaleRunningAsError.mockImplementation(() => 0);
     mockProcessMessage.mockClear();
-    mockEmitFeedEvent.mockClear();
+    emittedNotificationSignals.length = 0;
   });
 
-  test("skips without creating heartbeat rows, conversations, or feed events", async () => {
+  test("skips without creating heartbeat rows, conversations, or notifications", async () => {
     const service = new HeartbeatService({
       alerter: () => {},
     });
@@ -148,7 +161,7 @@ describe("HeartbeatService disk pressure gate", () => {
     expect(mockSkipHeartbeatRun).not.toHaveBeenCalled();
     expect(createdConversations).toHaveLength(0);
     expect(mockProcessMessage).not.toHaveBeenCalled();
-    expect(mockEmitFeedEvent).not.toHaveBeenCalled();
+    expect(emittedNotificationSignals).toHaveLength(0);
   });
 
   test("allows forced user-initiated heartbeat runs while locked", async () => {
@@ -168,7 +181,7 @@ describe("HeartbeatService disk pressure gate", () => {
     expect(mockProcessMessage).toHaveBeenCalledTimes(1);
   });
 
-  test("start recovery skips missed-run feed events while locked", async () => {
+  test("start recovery skips missed-run notifications while locked", async () => {
     mockMarkStaleRunsAsMissed.mockImplementationOnce(() => 1);
     const service = new HeartbeatService({
       alerter: () => {},
@@ -178,6 +191,6 @@ describe("HeartbeatService disk pressure gate", () => {
     await service.stop();
 
     expect(mockMarkStaleRunsAsMissed).toHaveBeenCalledTimes(1);
-    expect(mockEmitFeedEvent).not.toHaveBeenCalled();
+    expect(emittedNotificationSignals).toHaveLength(0);
   });
 });