@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/messaging/providers/__tests__/proactive-address.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+// The addressing capability resolves a named chat into exactly what each
+// transport's own operations read: the callback URL `channelForCallback`
+// resolves and the params `deliver` consumes. Resolution is local, so these
+// assertions make no platform call; the tests import the transports'
+// modules, which pull in their provider-API senders, so the senders'
+// credential lookups are stubbed to keep the import inert.
+import { mock } from "bun:test";
+
+const actualSecureKeys = await import("../../../security/secure-keys.js");
+mock.module("../../../security/secure-keys.js", () => ({
+  ...actualSecureKeys,
+  getSecureKeyAsync: async () => null,
+  getSecureKeyResultAsync: async () => ({ value: null }),
+}));
+
+const { channelForCallback } = await import("../callback-routing.js");
+const { discordTransport } = await import("../discord/transport.js");
+const { slackTransport } = await import("../slack/transport.js");
+const { telegramTransport } = await import("../telegram-bot/transport.js");
+const { whatsappTransport } = await import("../whatsapp/transport.js");
+
+describe("addressFor resolves to the channel's own routing state", () => {
+  test("slack: a chat, optionally under a thread", () => {
+    const room = slackTransport.addressFor!({ kind: "chat", chatId: "C123" });
+    expect(room).toEqual({
+      ctx: { callbackUrl: "/deliver/slack", params: {} },
+      chatId: "C123",
+    });
+    const thread = slackTransport.addressFor!({
+      kind: "chat",
+      chatId: "C123",
+      threadId: "1690000000.000001",
+    });
+    expect(thread).toEqual({
+      ctx: {
+        callbackUrl: "/deliver/slack?threadTs=1690000000.000001",
+        params: { threadTs: "1690000000.000001" },
+      },
+      chatId: "C123",
+      threadId: "1690000000.000001",
+    });
+    expect(channelForCallback(thread!.ctx.callbackUrl)).toBe("slack");
+  });
+
+  test("telegram: a chat with a topic; binds on send", () => {
+    expect(
+      telegramTransport.addressFor!({
+        kind: "chat",
+        chatId: "123",
+        threadId: "42",
+      }),
+    ).toEqual({
+      ctx: {
+        callbackUrl: "/deliver/telegram?threadId=42",
+        params: { threadId: "42" },
+      },
+      chatId: "123",
+      threadId: "42",
+    });
+    expect(telegramTransport.bindsChatOnProactiveSend).toBe(true);
+  });
+
+  test("discord: a chat with a thread, which is its own channel", () => {
+    const thread = discordTransport.addressFor!({
+      kind: "chat",
+      chatId: "C1",
+      threadId: "T1",
+    });
+    expect(thread).toEqual({
+      ctx: {
+        callbackUrl: "/deliver/discord?threadId=T1",
+        params: { threadId: "T1" },
+      },
+      chatId: "C1",
+      threadId: "T1",
+    });
+    expect(channelForCallback(thread!.ctx.callbackUrl)).toBe("discord");
+    expect(discordTransport.bindsChatOnProactiveSend).toBeUndefined();
+  });
+
+  test("whatsapp: the number is the chat; no threads; binds on send", () => {
+    expect(
+      whatsappTransport.addressFor!({
+        kind: "chat",
+        chatId: "12125550100",
+        threadId: "ignored",
+      }),
+    ).toEqual({
+      ctx: { callbackUrl: "/deliver/whatsapp", params: {} },
+      chatId: "12125550100",
+    });
+    expect(whatsappTransport.bindsChatOnProactiveSend).toBe(true);
+  });
+});

package/src/messaging/providers/callback-routing.ts

@@ -1,4 +1,5 @@
 import type { ChannelId } from "../../channels/types.js";
+import type { CallbackContext } from "./channel-transport.js";
 
 /**
  * Channels whose outbound replies the assistant delivers directly to the
@@ -22,6 +23,23 @@ export type DirectDeliveryChannel = (typeof DIRECT_DELIVERY_CHANNELS)[number];
 
 const CALLBACK_PREFIX = "/deliver/";
 
+/**
+ * The callback context a channel's operations read for a direct delivery
+ * that no inbound message brought a callback for: the channel's `/deliver`
+ * path with its per-channel params, spelled the way `channelForCallback`
+ * resolves it and the way the transports read it.
+ */
+export function directDeliveryContext(
+  channel: DirectDeliveryChannel,
+  params: Readonly<Record<string, string>> = {},
+): CallbackContext {
+  const query = new URLSearchParams(params).toString();
+  return {
+    callbackUrl: `${CALLBACK_PREFIX}${channel}${query ? `?${query}` : ""}`,
+    params,
+  };
+}
+
 /**
  * Resolve a gateway callback URL to the direct-delivery channel that owns it, or
  * `undefined` when no channel delivers it directly.

package/src/messaging/providers/channel-transport.ts

@@ -97,6 +97,35 @@ export interface ReactionTarget {
   readonly action: "add" | "remove";
 }
 
+/**
+ * Where a proactive send goes, in the caller's vocabulary rather than any
+ * channel's: a chat the caller already knows, optionally a thread within it.
+ * How a thread is spelled is each channel's own business.
+ *
+ * Tagged with its kind so a second way of naming a destination is additive
+ * rather than a reinterpretation of `chatId`. Reaching a person who has not
+ * been named as a chat is deliberately not a kind here: on Slack and Discord
+ * it costs a platform call whose result must be resolved at send time rather
+ * than stored, and nothing asks for it yet.
+ */
+export type ProactiveTarget = {
+  readonly kind: "chat";
+  readonly chatId: string;
+  readonly threadId?: string;
+};
+
+/**
+ * A proactive target resolved into what this channel's operations read: the
+ * callback context carrying the channel's routing state, the chat id
+ * `deliver` posts to, and the thread the post lands in, absent when it is
+ * not in one.
+ */
+export interface ProactiveAddress {
+  readonly ctx: CallbackContext;
+  readonly chatId: string;
+  readonly threadId?: string;
+}
+
 /**
  * Direct outbound delivery for one channel, wrapping the channel's provider-API
  * send functions behind a uniform surface. Transports are registered statically
@@ -111,6 +140,33 @@ export interface ChannelTransport {
   /** Canonical source channel id, e.g. `"slack"`. */
   readonly channel: ChannelId;
 
+  /**
+   * Resolve a target the caller names into this channel's own routing state,
+   * for a send that no inbound message brought a callback for.
+   *
+   * Implementing it is the whole of declaring that the channel can be
+   * addressed from a named chat. A transport that can only answer on the
+   * callback an inbound message carried omits it, and a caller reads the
+   * omission as "not addressable" rather than switching on the channel's
+   * name. Returning `undefined` for a target this channel cannot address is
+   * the same answer for that target alone.
+   *
+   * Resolution is local: it reads the target and the channel's own
+   * vocabulary, and makes no platform call. A destination that has to be
+   * resolved over the network belongs behind its own capability, so this one
+   * stays cheap enough to call on every send.
+   */
+  addressFor?(target: ProactiveTarget): ProactiveAddress | undefined;
+
+  /**
+   * Whether a proactive send to a chat must also bind that chat's inbound
+   * conversation, so the next message from the chat resolves to the same
+   * conversation the post lives in. Declared by a channel whose inbound
+   * conversations are keyed per chat and can be reset between sends; omitted
+   * by one whose inbound binding is made at ingress and keyed by thread.
+   */
+  readonly bindsChatOnProactiveSend?: boolean;
+
   /** Deliver a rendered reply (text / approval / attachments). */
   deliver(
     ctx: CallbackContext,

package/src/messaging/providers/discord/transport.ts

@@ -1,6 +1,7 @@
 import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type {
   CallbackContext,
   ChannelTransport,
@@ -51,6 +52,22 @@ async function sendTarget(
 export const discordTransport: ChannelTransport = {
   channel: "discord",
 
+  /**
+   * A chat is a channel id, with `threadId` naming the thread, which is its
+   * own channel. Reaching a person who has not been named as a chat would
+   * mean opening their DM first, a platform call this resolution does not
+   * make; the inbound `dm` param below is how an event-carried callback says
+   * its `chatId` is a recipient rather than a room.
+   */
+  addressFor(target) {
+    const threadId = target.threadId?.trim();
+    return {
+      ctx: directDeliveryContext("discord", threadId ? { threadId } : {}),
+      chatId: target.chatId,
+      ...(threadId ? { threadId } : {}),
+    };
+  },
+
   // Discord clears a typing indicator after ten seconds.
   activityRefreshMs: 8_000,
 

package/src/messaging/providers/slack/__tests__/adapter-token-routing.test.ts

@@ -162,10 +162,11 @@ describe("Slack adapter token routing", () => {
     globalThis.fetch = originalFetch;
   });
 
-  test("bot-token only: reads and writes both authenticate with the bot token (regression guard for pre-user-token behavior)", async () => {
+  test("bot-token only: reads authenticate with the bot token (regression guard for pre-user-token behavior)", async () => {
     // With only a bot token stored, reads must fall back to the bot token
     // so the adapter keeps working for installs that haven't re-consented
-    // the user scope. Writes stay on the bot token always.
+    // the user scope. Writes are not the adapter's: they go through the
+    // channel transport's senders, which always post as the bot.
     const resolved = await slackProvider.resolveConnection!();
     expect(resolved).toBeUndefined();
 
@@ -176,18 +177,12 @@ describe("Slack adapter token routing", () => {
     );
     expect(readCall).toBeDefined();
     expect(readCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
-
-    // Write path: sendMessage → /chat.postMessage must also use bot token.
-    await slackProvider.sendMessage(undefined, "C123", "hello");
-    const writeCall = captured.find((c) => c.url.includes("/chat.postMessage"));
-    expect(writeCall).toBeDefined();
-    expect(writeCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
   });
 
-  test("bot + user tokens: reads authenticate with the user token, writes with the bot token", async () => {
+  test("bot + user tokens: reads authenticate with the user token", async () => {
     // With both tokens stored, reads MUST flip to the user token so the
-    // adapter can see channels the user is in but the bot isn't. Writes
-    // MUST stay on the bot token so posts come from the bot identity.
+    // adapter can see channels the user is in but the bot isn't. Posts are
+    // the transport's and come from the bot identity there.
     getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
       if (key === credentialKey("slack_channel", "bot_token")) {
         return BOT_TOKEN;
@@ -217,12 +212,6 @@ describe("Slack adapter token routing", () => {
     expect(historyCall).toBeDefined();
     expect(historyCall!.authorization).toBe(`Bearer ${USER_TOKEN}`);
 
-    // Writes: sendMessage → bot token.
-    await slackProvider.sendMessage(undefined, "C123", "hello");
-    const sendCall = captured.find((c) => c.url.includes("/chat.postMessage"));
-    expect(sendCall).toBeDefined();
-    expect(sendCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
-
     // markRead → user token. conversations.mark sets the read cursor for
     // the authenticated identity, so it must use the same token whose unread
     // counts the adapter exposes.

package/src/messaging/providers/slack/adapter.ts

@@ -28,8 +28,6 @@ import type {
   Message,
   SearchOptions,
   SearchResult,
-  SendOptions,
-  SendResult,
 } from "../../provider-types.js";
 import { resolveSlackAuth } from "./auth.js";
 import * as slack from "./client.js";
@@ -144,24 +142,12 @@ function getReadAuth(connection?: OAuthConnection): OAuthConnection | string {
   return getSlackAuth(connection);
 }
 
-// SAFETY: content-creating writes (postMessage, updateMessage, deleteMessage,
-// reactions) MUST use the bot token. Using the user token would post as the
-// user, not as the bot. State-changing methods that target the authenticated
-// identity's own state (e.g. conversations.mark) should use the read auth so
-// the cursor matches the perspective the adapter exposes.
-/**
- * Resolve auth for content-creating write operations (postMessage and any
- * future reactions, joins, leaves, updates, or deletes).
- */
-function getWriteAuth(connection?: OAuthConnection): OAuthConnection | string {
-  if (connection) {
-    return connection;
-  }
-  if (_cachedSlackWriteAuth) {
-    return _cachedSlackWriteAuth;
-  }
-  return getSlackAuth(connection);
-}
+// SAFETY: content-creating writes (posts, updates, deletes, reactions) go
+// through the channel transport's senders, which authenticate with the bot
+// token so posts come from the bot identity. State-changing methods that
+// target the authenticated identity's own state (e.g. conversations.mark)
+// use the read auth so the cursor matches the perspective the adapter
+// exposes.
 
 /**
  * Resolve the bot token (raw string) and pass it to `fn`. Returns the
@@ -171,7 +157,7 @@ function getWriteAuth(connection?: OAuthConnection): OAuthConnection | string {
  * (`OAuthConnection.withToken`) for callers that need a raw token to hand
  * to a non-Slack-client API call — currently `downloadSlackFile` for inline
  * file/image fetches. Slack-client method calls should keep going through
- * `getReadAuth` / `getWriteAuth` and pass the union through.
+ * `getReadAuth` and pass the union through.
  */
 export async function withSlackBotToken<T>(
   account: string | undefined,
@@ -830,29 +816,6 @@ export const slackProvider: MessagingProvider = {
     };
   },
 
-  async sendMessage(
-    connection: OAuthConnection | undefined,
-    conversationId: string,
-    text: string,
-    options?: SendOptions,
-  ): Promise<SendResult> {
-    const auth = getWriteAuth(connection);
-    const resp = await slack.postMessage(
-      auth,
-      conversationId,
-      text,
-      options?.threadId,
-    );
-    // The thread reported is the one the post landed in, which is the one
-    // requested, since chat.postMessage threads exactly where it is told.
-    return {
-      id: resp.ts,
-      timestamp: parseFloat(resp.ts) * 1000,
-      conversationId: resp.channel,
-      ...(options?.threadId ? { threadId: options.threadId } : {}),
-    };
-  },
-
   async getThreadReplies(
     connection: OAuthConnection | undefined,
     conversationId: string,

package/src/messaging/providers/slack/transport.ts

@@ -3,6 +3,7 @@ import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { extractThreadTsFromCallbackUrl } from "../../../channels/slack-callback-url.js";
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type { ChannelTransport } from "../channel-transport.js";
 import { SLACK_STREAM_MARKDOWN_LIMIT } from "./api.js";
 import {
@@ -25,6 +26,21 @@ function mutedBlocks(text: string): KnownBlock[] {
 export const slackTransport: ChannelTransport = {
   channel: "slack",
 
+  /**
+   * A chat is a channel or DM id, with `threadTs` naming the thread to post
+   * under. Reaching a person who has not been named as a chat would mean
+   * opening the DM first (`conversations.open`), a platform call this
+   * resolution does not make.
+   */
+  addressFor(target) {
+    const threadTs = target.threadId?.trim();
+    return {
+      ctx: directDeliveryContext("slack", threadTs ? { threadTs } : {}),
+      chatId: target.chatId,
+      ...(threadTs ? { threadId: threadTs } : {}),
+    };
+  },
+
   describeReactionEmoji: describeSlackReactionEmoji,
 
   async react(target) {

package/src/messaging/providers/telegram-bot/adapter.ts

@@ -6,9 +6,6 @@
 
 import type { OAuthConnection } from "../../../oauth/connection.js";
 import { getConnectionByProvider } from "../../../oauth/oauth-store.js";
-import { getOrCreateConversation } from "../../../persistence/conversation-key-store.js";
-import { buildScopedConversationKey } from "../../../persistence/delivery-crud.js";
-import { upsertOutboundBinding } from "../../../persistence/external-conversation-store.js";
 import { credentialKey } from "../../../security/credential-key.js";
 import { getSecureKeyAsync } from "../../../security/secure-keys.js";
 import type { MessagingProvider } from "../../provider.js";
@@ -20,8 +17,6 @@ import type {
   Message,
   SearchOptions,
   SearchResult,
-  SendOptions,
-  SendResult,
 } from "../../provider-types.js";
 import * as telegram from "./client.js";
 
@@ -34,7 +29,7 @@ export const telegramBotMessagingProvider: MessagingProvider = {
   id: "telegram",
   displayName: "Telegram",
   credentialService: "telegram",
-  capabilities: new Set(["send"]),
+  capabilities: new Set(),
 
   async isConnected(): Promise<boolean> {
     const conn = getConnectionByProvider("telegram");
@@ -95,48 +90,6 @@ export const telegramBotMessagingProvider: MessagingProvider = {
     }
   },
 
-  async sendMessage(
-    _connection: OAuthConnection | undefined,
-    conversationId: string,
-    text: string,
-    _options?: SendOptions,
-  ): Promise<SendResult> {
-    const sent = await telegram.sendMessage(conversationId, text);
-    if (!sent.lastMessageId) {
-      throw new Error(
-        "Telegram accepted the message but returned no message id",
-      );
-    }
-
-    // Upsert external conversation binding so deleted/reset syncs are
-    // resurrected when an outbound message is sent. This ensures the
-    // conversation key mapping and binding exist for the next inbound.
-    try {
-      const sourceChannel = "telegram";
-      const conversationKey = buildScopedConversationKey(
-        sourceChannel,
-        conversationId,
-      );
-      const { conversationId: internalId } =
-        getOrCreateConversation(conversationKey);
-      upsertOutboundBinding({
-        conversationId: internalId,
-        sourceChannel,
-        externalChatId: conversationId,
-      });
-    } catch {
-      // Best-effort — don't fail the send if binding upsert fails
-    }
-
-    // The id is the one Telegram assigned, so a later reaction, edit, or
-    // delete carrying that id resolves to this send.
-    return {
-      id: sent.lastMessageId,
-      timestamp: Date.now(),
-      conversationId,
-    };
-  },
-
   async listConversations(
     _connection?: OAuthConnection,
     _options?: ListOptions,

package/src/messaging/providers/telegram-bot/client.ts

@@ -41,29 +41,3 @@ export async function getMe(botToken: string): Promise<TelegramGetMeResponse> {
 
   return resp.json() as Promise<TelegramGetMeResponse>;
 }
-
-/** Result returned by sendMessage. */
-export interface TelegramSendResult {
-  ok: boolean;
-  /**
-   * The `message_id` Telegram assigned to the last chunk sent. Telegram
-   * returns the sent Message on every successful `sendMessage`, so this is
-   * absent only when the API answered with an unexpected shape.
-   */
-  lastMessageId?: string;
-}
-
-/**
- * Send a Telegram text message via the Bot API directly.
- *
- * Delegates to sendTelegramReply which handles text splitting (Telegram's
- * sendMessage API has a 4096-char limit per call).
- */
-export async function sendMessage(
-  chatId: string,
-  text: string,
-): Promise<TelegramSendResult> {
-  const { sendTelegramReply } = await import("./send.js");
-  const sent = await sendTelegramReply(chatId, text);
-  return { ok: true, lastMessageId: sent.lastMessageId };
-}

package/src/messaging/providers/telegram-bot/transport.ts

@@ -2,6 +2,7 @@ import type { StreamPlan, StreamPlanStep } from "@vellumai/gateway-client";
 import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type {
   CallbackContext,
   ChannelTransport,
@@ -66,6 +67,25 @@ function mintDraftId(): number {
 export const telegramTransport: ChannelTransport = {
   channel: "telegram",
 
+  /**
+   * A chat is a chat id, with `threadId` naming a forum topic. A person's DM
+   * chat id is their user id on Telegram, so reaching one is naming that
+   * chat and needs no resolution of its own.
+   */
+  addressFor(target) {
+    const threadId = target.threadId?.trim();
+    return {
+      ctx: directDeliveryContext("telegram", threadId ? { threadId } : {}),
+      chatId: target.chatId,
+      ...(threadId ? { threadId } : {}),
+    };
+  },
+
+  // A Telegram chat's inbound conversation is keyed per chat and can be
+  // reset or deleted between sends; a proactive post re-binds it so the
+  // next inbound from the chat lands where the post lives.
+  bindsChatOnProactiveSend: true,
+
   // Telegram clears a chat action after about five seconds.
   activityRefreshMs: 4_000,
 

package/src/messaging/providers/whatsapp/adapter.ts

@@ -5,8 +5,6 @@
  */
 
 import type { OAuthConnection } from "../../../oauth/connection.js";
-import { getOrCreateConversation } from "../../../persistence/conversation-key-store.js";
-import { upsertOutboundBinding } from "../../../persistence/external-conversation-store.js";
 import { credentialKey } from "../../../security/credential-key.js";
 import { getSecureKeyAsync } from "../../../security/secure-keys.js";
 import type { MessagingProvider } from "../../provider.js";
@@ -18,10 +16,7 @@ import type {
   Message,
   SearchOptions,
   SearchResult,
-  SendOptions,
-  SendResult,
 } from "../../provider-types.js";
-import * as whatsapp from "./client.js";
 
 /** Check whether WhatsApp credentials are stored. */
 async function hasWhatsAppCredentials(): Promise<boolean> {
@@ -41,7 +36,7 @@ export const whatsappMessagingProvider: MessagingProvider = {
   id: "whatsapp",
   displayName: "WhatsApp",
   credentialService: "whatsapp",
-  capabilities: new Set(["send"]),
+  capabilities: new Set(),
 
   async isConnected(): Promise<boolean> {
     return hasWhatsAppCredentials();
@@ -74,48 +69,6 @@ export const whatsappMessagingProvider: MessagingProvider = {
     };
   },
 
-  async sendMessage(
-    _connection: OAuthConnection | undefined,
-    conversationId: string,
-    text: string,
-    options?: SendOptions,
-  ): Promise<SendResult> {
-    const assistantId = options?.assistantId;
-
-    const sent = await whatsapp.sendMessage(conversationId, text);
-    if (!sent.messageId) {
-      throw new Error(
-        "WhatsApp accepted the message but returned no message id",
-      );
-    }
-
-    // Upsert external conversation binding so the conversation key mapping
-    // exists for the next inbound WhatsApp message from this number.
-    try {
-      const sourceChannel = "whatsapp";
-      const conversationKey = `asst:${assistantId ?? "self"}:${sourceChannel}:${conversationId}`;
-      const { conversationId: internalId } =
-        getOrCreateConversation(conversationKey);
-      if (!assistantId || assistantId === "self") {
-        upsertOutboundBinding({
-          conversationId: internalId,
-          sourceChannel,
-          externalChatId: conversationId,
-        });
-      }
-    } catch {
-      // Best-effort — don't fail the send if binding upsert fails
-    }
-
-    // The id is the one the Cloud API assigned, so a later reaction or
-    // delete carrying that id resolves to this send.
-    return {
-      id: sent.messageId,
-      timestamp: Date.now(),
-      conversationId,
-    };
-  },
-
   async listConversations(
     _connection?: OAuthConnection,
     _options?: ListOptions,

package/src/messaging/providers/whatsapp/transport.ts

@@ -1,6 +1,7 @@
 import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type { ChannelTransport } from "../channel-transport.js";
 import { sendWhatsAppAttachments, sendWhatsAppReply } from "./send.js";
 
@@ -9,6 +10,23 @@ const log = getLogger("whatsapp-transport");
 export const whatsappTransport: ChannelTransport = {
   channel: "whatsapp",
 
+  /**
+   * A chat is the phone number, which is also how a person is named, so
+   * reaching one needs no resolution of its own. There are no threads, so a
+   * target's thread is not carried and the post lands in the chat itself.
+   */
+  addressFor(target) {
+    return {
+      ctx: directDeliveryContext("whatsapp"),
+      chatId: target.chatId,
+    };
+  },
+
+  // A WhatsApp number's inbound conversation is keyed per chat and can be
+  // reset between sends; a proactive post re-binds it so the next inbound
+  // from the number lands where the post lives.
+  bindsChatOnProactiveSend: true,
+
   async deliver(_ctx, payload) {
     const { chatId, text, attachments, approval } = payload;
 

package/src/monitoring/__tests__/workspace-git-heartbeat.test.ts

@@ -54,4 +54,12 @@ describe("workspace git heartbeat on the monitoring worker", () => {
     expect(worker).toContain("await workspaceGitHeartbeat?.stop()");
     expect(lifecycle).not.toContain("startWorkspaceHeartbeatService");
   });
+
+  test("daemon lifecycle does not stop the in-process heartbeat singleton", () => {
+    const shutdown = readFileSync(
+      join(SRC_ROOT, "daemon/shutdown-handlers.ts"),
+      "utf8",
+    );
+    expect(shutdown).not.toContain("stopWorkspaceHeartbeatService");
+  });
 });