@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -223,9 +223,9 @@ describe("loadExternalPlugin — hooks", () => {
     );
     expect(typeof registered?.hooks?.init).toBe("function");
     await registered?.hooks?.init?.({} as never);
-    expect(
-      (globalThis as Record<string, unknown>).__externalInitCalled,
-    ).toBe(true);
+    expect((globalThis as Record<string, unknown>).__externalInitCalled).toBe(
+      true,
+    );
     delete (globalThis as Record<string, unknown>).__externalInitCalled;
   });
 
@@ -290,9 +290,9 @@ describe("loadExternalPlugin — hooks", () => {
     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,
-    );
+    expect(
+      (globalThis as Record<string, unknown>).__externalDtsInitCalled,
+    ).toBe(true);
     delete (globalThis as Record<string, unknown>).__externalDtsInitCalled;
   });
 
@@ -345,7 +345,6 @@ describe("loadExternalPlugin — tools", () => {
       dir,
       "tools/alpha.ts",
       `export default {
-  name: "two_tools_alpha",
   description: "alpha",
   defaultRiskLevel: "low" as const,
   input_schema: { type: "object", properties: {}, required: [] },
@@ -357,7 +356,6 @@ describe("loadExternalPlugin — tools", () => {
       dir,
       "tools/beta.ts",
       `export default {
-  name: "two_tools_beta",
   description: "beta",
   defaultRiskLevel: "low" as const,
   input_schema: { type: "object", properties: {}, required: [] },
@@ -374,7 +372,7 @@ describe("loadExternalPlugin — tools", () => {
     const names = (registered?.tools ?? []).map(
       (t) => (t as { name: string }).name,
     );
-    expect(names).toEqual(["two_tools_alpha", "two_tools_beta"]);
+    expect(names).toEqual(["alpha", "beta"]);
   });
 
   test("plugin.tools is undefined when tools/ is absent", async () => {
@@ -403,18 +401,95 @@ describe("loadExternalPlugin — tools", () => {
     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" });
+  test("a tool default export with missing fields loads with documented defaults", async () => {
+    const dir = freshPluginDir("tool-with-defaults");
+    writePackageJson(dir, { name: "tool-with-defaults", version: "0.1.0" });
+    // The default export is a bare empty object — no description,
+    // defaultRiskLevel, input_schema, or execute. The loader must fill
+    // each slot with its documented default and still register the plugin.
+    writeSurfaceFile(dir, "tools/empty.ts", `export default {};\n`);
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "tool-with-defaults",
+    );
+    expect(registered).toBeDefined();
+    const tools = (registered?.tools ?? []) as Array<{
+      name: string;
+      description: string;
+      defaultRiskLevel: string;
+      input_schema: Record<string, unknown>;
+      execute: (
+        input: Record<string, unknown>,
+        context: unknown,
+      ) => Promise<{ content: string; isError: boolean }>;
+    }>;
+    expect(tools).toHaveLength(1);
+    const empty = tools[0]!;
+    expect(empty.name).toBe("empty");
+    expect(empty.description).toBe("");
+    expect(empty.defaultRiskLevel).toBe("medium");
+    expect(empty.input_schema).toEqual({
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    });
+    expect(typeof empty.execute).toBe("function");
+
+    const result = await empty.execute({}, {} as unknown);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("empty");
+    expect(result.content).toContain("no execute implementation");
+  });
+
+  test("a partial tool default export merges author fields with defaults", async () => {
+    const dir = freshPluginDir("tool-partial-defaults");
+    writePackageJson(dir, {
+      name: "tool-partial-defaults",
+      version: "0.1.0",
+    });
+    // Author supplies only description + execute; the loader must default
+    // defaultRiskLevel and input_schema while keeping the author's fields.
     writeSurfaceFile(
       dir,
-      "tools/nameless.ts",
-      `export default { description: "missing name" };\n`,
+      "tools/partial.ts",
+      `export default {
+  description: "custom description",
+  async execute() {
+    return { content: "ran", isError: false };
+  },
+};
+`,
     );
 
     await loadExternalPlugin(dir);
 
-    expect(registeredNames()).toHaveLength(0);
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "tool-partial-defaults",
+    );
+    const tool = (registered?.tools ?? [])[0] as
+      | {
+          description: string;
+          defaultRiskLevel: string;
+          input_schema: object;
+          execute: (
+            input: Record<string, unknown>,
+            context: unknown,
+          ) => Promise<{ content: string; isError: boolean }>;
+        }
+      | undefined;
+    expect(tool).toBeDefined();
+    expect(tool?.description).toBe("custom description");
+    expect(tool?.defaultRiskLevel).toBe("medium");
+    expect(tool?.input_schema).toEqual({
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    });
+    const result = await tool!.execute({}, {} as unknown);
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("ran");
   });
 });
 
@@ -474,9 +549,6 @@ describe("loadExternalPlugin — end-to-end @vellumai/simple-memory", () => {
     const toolNames = (registered?.tools ?? [])
       .map((t) => (t as { name: string }).name)
       .sort();
-    expect(toolNames).toEqual([
-      "simple_memory_recall",
-      "simple_memory_remember",
-    ]);
+    expect(toolNames).toEqual(["recall", "remember"]);
   });
 });

package/src/__tests__/first-greeting.test.ts

@@ -4,8 +4,12 @@ import { describe, expect, it } from "bun:test";
 
 const tempDir = process.env.VELLUM_WORKSPACE_DIR!;
 
-const { isWakeUpGreeting, getCannedFirstGreeting, CANNED_FIRST_GREETING } =
-  await import("../daemon/first-greeting.js");
+const {
+  isWakeUpGreeting,
+  getCannedFirstGreeting,
+  buildScanFirstMessage,
+  CANNED_FIRST_GREETING,
+} = await import("../daemon/first-greeting.js");
 import type { OnboardingGreetingContext } from "../daemon/first-greeting.js";
 
 describe("first-greeting", () => {
@@ -270,6 +274,23 @@ describe("first-greeting", () => {
     });
   });
 
+  describe("buildScanFirstMessage", () => {
+    it("website variant includes 'my website' and the URL", () => {
+      const msg = buildScanFirstMessage("https://acme.com", "website");
+      expect(msg).toContain("my website");
+      expect(msg).toContain("https://acme.com");
+    });
+
+    it("content-source variant includes 'content' and the URL", () => {
+      const msg = buildScanFirstMessage(
+        "https://blog.acme.com/post",
+        "content-source",
+      );
+      expect(msg).toContain("content");
+      expect(msg).toContain("https://blog.acme.com/post");
+    });
+  });
+
   describe("tasks and tools fields are ignored", () => {
     it("tasks do not appear in output", () => {
       const greeting = getCannedFirstGreeting({

package/src/__tests__/guardian-action-no-hardcoded-copy.test.ts

@@ -20,7 +20,6 @@ const SCANNED_FILES = [
   "calls/call-controller.ts",
   "calls/guardian-action-sweep.ts",
   "runtime/routes/inbound-message-handler.ts",
-  "runtime/guardian-action-conversation-turn.ts",
   "daemon/conversation-process.ts",
 ];
 

package/src/__tests__/guardian-dispatch.test.ts

@@ -295,6 +295,7 @@ describe("guardian-dispatch", () => {
       conversationId: "conv-from-thread-created",
       title: "Guardian alert",
       sourceEventName: "guardian.question",
+      silent: false,
     };
     mockEmitResult = {
       signalId: "sig-4",

package/src/__tests__/headless-browser-navigate.test.ts

@@ -27,6 +27,7 @@ let cdpSendHandler: (
   params?: Record<string, unknown>,
 ) => unknown = () => ({});
 let cdpDisposed = false;
+let cdpSetSessionIdCalls: Array<string | undefined> = [];
 
 function makeFakeCdp(kind: "local" | "extension", conversationId: string) {
   return {
@@ -43,6 +44,12 @@ function makeFakeCdp(kind: "local" | "extension", conversationId: string) {
     dispose() {
       cdpDisposed = true;
     },
+    // Mirrors the optional method on the real CdpClient interface so
+    // the --new-tab path can be exercised end-to-end. Recorded for
+    // per-test assertions.
+    setCdpSessionId(cdpSessionId: string | undefined) {
+      cdpSetSessionIdCalls.push(cdpSessionId);
+    },
   };
 }
 
@@ -135,6 +142,7 @@ mock.module("../tools/network/url-safety.js", () => ({
 }));
 
 import { executeBrowserNavigate } from "../tools/browser/browser-execution.js";
+import { __resetPinnedTabsForTests } from "../tools/browser/pinned-tabs.js";
 import type { ToolContext } from "../tools/types.js";
 
 const ctx: ToolContext = {
@@ -212,6 +220,7 @@ function resetCdp() {
   cdpSendCalls = [];
   cdpDisposed = false;
   cdpSendHandler = defaultCdpHandler;
+  cdpSetSessionIdCalls = [];
 }
 
 describe("executeBrowserNavigate", () => {
@@ -223,6 +232,7 @@ describe("executeBrowserNavigate", () => {
     resolveResult = {};
     resetMockPage();
     resetCdp();
+    __resetPinnedTabsForTests();
   });
 
   // ── Input validation ───────────────────────────────────────────
@@ -664,6 +674,168 @@ describe("executeBrowserNavigate", () => {
     expect(cdpDisposed).toBe(true);
   });
 
+  // ── --new-tab flag (extension path only) ──────────────────────
+
+  test("extension path with new_tab: true opens a fresh tab and pins it before Page.navigate", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return { tabId: "999" };
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+
+    // Vellum.createTab fired and fired BEFORE Page.navigate.
+    const createIdx = cdpSendCalls.findIndex(
+      (c) => c.method === "Vellum.createTab",
+    );
+    const navIdx = cdpSendCalls.findIndex((c) => c.method === "Page.navigate");
+    expect(createIdx).toBeGreaterThanOrEqual(0);
+    expect(navIdx).toBeGreaterThanOrEqual(0);
+    expect(createIdx).toBeLessThan(navIdx);
+
+    // setCdpSessionId was invoked with the returned tabId so the
+    // follow-on commands on this client route to the new tab.
+    expect(cdpSetSessionIdCalls).toContain("999");
+  });
+
+  test("new_tab: true on extension path with createTab failure aborts with a clear error", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") {
+        throw new Error("createTab returned no tabId");
+      }
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Failed to open a new tab");
+    // Page.navigate must NOT fire — that's exactly what --new-tab is
+    // supposed to prevent in the failure case (silent fallback to
+    // active-tab clobbering would defeat the purpose of the flag).
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(false);
+    // The createTab-failure path early-returns BEFORE the main
+    // try/finally that wraps the navigate flow, so the executor has to
+    // dispose the CDP client manually. Verifying here so future edits
+    // to that early-return don't silently regress the cleanup.
+    expect(cdpDisposed).toBe(true);
+  });
+
+  test("new_tab: true on extension path with no tabId in response clears live session and still continues", async () => {
+    // Defensive: dispatcher returns success but no tabId. The
+    // executor logs a warn, resets the live cdp session to undefined
+    // (so the follow-on Page.navigate routes to the active tab
+    // instead of any stale pin the cdp instance was constructed
+    // with), and proceeds. The navigate still runs (degraded
+    // behaviour but not a hard failure).
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return {}; // no tabId
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // No new pin was set, BUT the live session was reset to undefined
+    // so the follow-on Page.navigate falls back to active-tab routing
+    // instead of any stale pin the cdp instance held at construction.
+    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    // Page.navigate still ran.
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
+  });
+
+  test("new_tab: true with no tabId in response clears a pre-existing stale pin AND live session (regression)", async () => {
+    // Regression for the Codex round-2 findings (P2 + round-3 P1):
+    // when Vellum.createTab returns a malformed response with no
+    // tabId, the executor falls back to active-tab routing — but
+    // (a) the pin store still held the stale pin (round-2 P2 fix
+    // added clearPinnedTab), and (b) the LIVE cdp instance was
+    // already constructed with that stale cdpSessionId, so the
+    // follow-on Page.navigate would still route to the dead tab
+    // unless we reset the session on the cdp instance too (round-3
+    // P1 fix added cdp.setCdpSessionId(undefined)).
+    const { setPinnedTab, getPinnedTab } = await import(
+      "../tools/browser/pinned-tabs.js"
+    );
+    setPinnedTab(ctx.conversationId, "stale-pinned-tab-id");
+    expect(getPinnedTab(ctx.conversationId)).toBe("stale-pinned-tab-id");
+
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return {}; // no tabId
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // (a) Pin store cleared.
+    expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
+    // (b) Live cdp session reset (the fake records every
+    // setCdpSessionId arg; expect exactly one call with undefined).
+    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+  });
+
+  test("new_tab: true on LOCAL path is a no-op (Playwright manages its own isolated browser)", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = false; // local path
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // No Vellum.createTab was issued on the local path — the flag is
+    // silently ignored because Playwright opens its own browser and
+    // there's no user-tab to disturb.
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      false,
+    );
+    expect(cdpSetSessionIdCalls).toEqual([]);
+  });
+
+  test("absence of new_tab leaves extension path untouched (no Vellum.createTab)", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page" }, // no new_tab key at all
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      false,
+    );
+    expect(cdpSetSessionIdCalls).toEqual([]);
+  });
+
   // ── Defense-in-depth: post-navigation final URL check ─────────
 
   test("post-nav check blocks when final URL resolves to private target", async () => {

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

@@ -43,6 +43,7 @@ let mockConfig = {
     timezone: null as string | null,
     activeHoursStart: undefined as number | undefined,
     activeHoursEnd: undefined as number | undefined,
+    disposition: "Default disposition text mentioning notifications skill.",
   },
 };
 
@@ -386,6 +387,7 @@ describe("HeartbeatService", () => {
         timezone: null,
         activeHoursStart: undefined,
         activeHoursEnd: undefined,
+        disposition: "Default disposition text mentioning notifications skill.",
       },
     };
   });
@@ -418,8 +420,7 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls[0].conversationId).toBe("conv-1");
     expect(processMessageCalls[0].content).toContain("<heartbeat-checklist>");
     expect(processMessageCalls[0].content).toContain("<heartbeat-disposition>");
-    expect(processMessageCalls[0].content).toContain("HEARTBEAT_OK");
-    expect(processMessageCalls[0].content).toContain("HEARTBEAT_ALERT");
+    expect(processMessageCalls[0].content).toContain("notifications skill");
   });
 
   test("HEARTBEAT.md content is embedded in prompt when file exists", async () => {
@@ -750,30 +751,13 @@ describe("HeartbeatService", () => {
     });
   });
 
-  test("HEARTBEAT_ALERT emits a notification signal and surfaces the conversation", async () => {
+  test("conversation surfaces to the sidebar on every successful run", async () => {
     const conversationCreatedCalls: Array<{
       conversationId: string;
       title: string;
     }> = [];
     const service = createService({
       onConversationCreated: (info) => conversationCreatedCalls.push(info),
-      processMessage: async (...args: unknown[]) => {
-        const conversationId = args[0] as string;
-        mockStoredMessages.push({
-          id: "assistant-alert-1",
-          conversationId,
-          role: "assistant",
-          content: JSON.stringify([
-            {
-              type: "text",
-              text: "The first heartbeat found a concrete follow-up for the guardian.\nHEARTBEAT_ALERT",
-            },
-          ]),
-          createdAt: Date.now(),
-          metadata: null,
-        });
-        return { messageId: "user-heartbeat-1" };
-      },
     });
 
     await service.runOnce();
@@ -782,113 +766,6 @@ describe("HeartbeatService", () => {
     expect(conversationCreatedCalls).toEqual([
       { conversationId: "conv-1", title: "Heartbeat" },
     ]);
-    expect(emittedNotificationSignals).toHaveLength(1);
-    expect(emittedNotificationSignals[0]).toMatchObject({
-      sourceEventName: "heartbeat.alert",
-      sourceChannel: "watcher",
-      sourceContextId: "mock-run-id",
-      dedupeKey: "heartbeat:alert:mock-run-id",
-      attentionHints: {
-        requiresAction: true,
-        urgency: "medium",
-        isAsyncBackground: true,
-        visibleInSourceNow: false,
-      },
-      conversationAffinityHint: { vellum: "conv-1" },
-      conversationMetadata: {
-        source: "heartbeat",
-        groupId: "system:background",
-      },
-    });
-    expect(emittedNotificationSignals[0].contextPayload.summary).toBe(
-      "The first heartbeat found a concrete follow-up for the guardian.",
-    );
-    expect(emittedNotificationSignals[0].contextPayload.messageId).toBe(
-      "assistant-alert-1",
-    );
-    expect(
-      emittedNotificationSignals[0].contextPayload.sourceInterface,
-    ).toBeUndefined();
-  });
-
-  test("HEARTBEAT_OK stays silent", async () => {
-    const conversationCreatedCalls: Array<{
-      conversationId: string;
-      title: string;
-    }> = [];
-    const service = createService({
-      onConversationCreated: (info) => conversationCreatedCalls.push(info),
-      processMessage: async (...args: unknown[]) => {
-        const conversationId = args[0] as string;
-        mockStoredMessages.push({
-          id: "assistant-ok-1",
-          conversationId,
-          role: "assistant",
-          content: JSON.stringify([
-            {
-              type: "text",
-              text: "Everything looks good.\nHEARTBEAT_OK",
-            },
-          ]),
-          createdAt: Date.now(),
-          metadata: null,
-        });
-        return { messageId: "user-heartbeat-1" };
-      },
-    });
-
-    await service.runOnce();
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    // The conversation surfaces to the sidebar via the runner's bootstrap
-    // callback for *every* heartbeat — "silent OK" means no notification
-    // signal is emitted, not that the conversation is hidden.
-    expect(conversationCreatedCalls).toHaveLength(1);
-    expect(emittedNotificationSignals).toHaveLength(0);
-  });
-
-  test("HEARTBEAT_OK stays silent when earlier content mentions HEARTBEAT_ALERT", async () => {
-    const conversationCreatedCalls: Array<{
-      conversationId: string;
-      title: string;
-    }> = [];
-    const service = createService({
-      onConversationCreated: (info) => conversationCreatedCalls.push(info),
-      processMessage: async (...args: unknown[]) => {
-        const conversationId = args[0] as string;
-        mockStoredMessages.push({
-          id: "assistant-ok-2",
-          conversationId,
-          role: "assistant",
-          content: JSON.stringify([
-            {
-              type: "thinking",
-              thinking:
-                "I should decide between HEARTBEAT_ALERT and HEARTBEAT_OK.",
-            },
-            {
-              type: "tool_result",
-              content: "Tool output mentions HEARTBEAT_ALERT.",
-            },
-            {
-              type: "text",
-              text: "I considered HEARTBEAT_ALERT, but there is nothing useful to surface.\nHEARTBEAT_OK",
-            },
-          ]),
-          createdAt: Date.now(),
-          metadata: null,
-        });
-        return { messageId: "user-heartbeat-1" };
-      },
-    });
-
-    await service.runOnce();
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    // Conversation surfaces via the runner bootstrap, but no notification
-    // is emitted since the disposition is OK.
-    expect(conversationCreatedCalls).toHaveLength(1);
-    expect(emittedNotificationSignals).toHaveLength(0);
   });
 
   test("end-to-end: llm.callSites.heartbeatAgent.speed resolves to 'fast'", async () => {
@@ -1524,43 +1401,6 @@ describe("HeartbeatService", () => {
       });
     });
 
-    test("CAS false suppresses success surfacing", async () => {
-      mockCompleteHeartbeatRun.mockImplementation(() => false);
-
-      const conversationCreatedCalls: Array<{
-        conversationId: string;
-        title: string;
-      }> = [];
-      const service = createService({
-        onConversationCreated: (info) => conversationCreatedCalls.push(info),
-        processMessage: async (...args: unknown[]) => {
-          const conversationId = args[0] as string;
-          mockStoredMessages.push({
-            id: "assistant-alert-1",
-            conversationId,
-            role: "assistant",
-            content: JSON.stringify([
-              {
-                type: "text",
-                text: "Something worth surfacing.\nHEARTBEAT_ALERT",
-              },
-            ]),
-            createdAt: Date.now(),
-            metadata: null,
-          });
-          return { messageId: "msg-1" };
-        },
-      });
-      await service.runOnce();
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      // The bootstrap-time surface fires regardless of CAS (it happens
-      // before completeHeartbeatRun). CAS-false suppresses the alert
-      // notification emit but not the sidebar entry.
-      expect(conversationCreatedCalls).toHaveLength(1);
-      expect(emittedNotificationSignals).toHaveLength(0);
-    });
-
     test("CAS false suppresses failure alerter and feed event", async () => {
       mockCompleteHeartbeatRun.mockImplementation(() => false);
 
@@ -1836,4 +1676,24 @@ describe("HeartbeatService", () => {
       expect(processMessageCalls[0].content).not.toContain("<early-heartbeat>");
     });
   });
+
+  describe("configurable disposition", () => {
+    test("injects the configured disposition inside <heartbeat-disposition>", () => {
+      mockConfig.heartbeat.disposition = "Marker text from config.";
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 10);
+
+      expect(prompt).toContain(
+        "<heartbeat-disposition>\nMarker text from config.\n</heartbeat-disposition>",
+      );
+    });
+
+    test("omits the block when disposition is empty", () => {
+      mockConfig.heartbeat.disposition = "";
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", [], 10);
+
+      expect(prompt).not.toContain("<heartbeat-disposition>");
+    });
+  });
 });

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -65,7 +65,6 @@ import type {
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
   GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
   MessageProcessor,
 } from "../../runtime/http-types.js";
 import {
@@ -113,7 +112,6 @@ export async function handleChannelInbound(
   _approvalCopyGenerator?: ApprovalCopyGenerator,
   _approvalConversationGenerator?: ApprovalConversationGenerator,
   _guardianActionCopyGenerator?: GuardianActionCopyGenerator,
-  _guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator,
 ): Promise<Response> {
   const body = await req.json();
   return wrapHandler(() => _handleChannelInbound({ body }));