@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/notifications/__tests__/assistant-reply-producer.test.ts

@@ -5,6 +5,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import { MESSAGE_KEYS } from "../../i18n/index.js";
 import type { AttentionState } from "../../persistence/conversation-attention-store.js";
 import type {
   ConversationRow,
@@ -589,6 +590,60 @@ describe("emitAssistantReplyNotification", () => {
     });
   });
 
+  // A conversation whose title is still being written stores the message key
+  // itself, which is a non-empty string the sanitizer has no reason to reject.
+  // Sending it would put a raw key on the lock screen, so it counts as absent.
+  test("omits requestedTitle while the title is still generating", async () => {
+    conversationRow = makeConversation({
+      title: MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING,
+    });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload).toEqual({
+      requestedMessage: "Sure, here is the plan.",
+    });
+  });
+
+  test("omits requestedTitle for the legacy generating placeholder", async () => {
+    conversationRow = makeConversation({ title: "Generating title..." });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload).toEqual({
+      requestedMessage: "Sure, here is the plan.",
+    });
+  });
+
+  test("omits requestedTitle for the untitled placeholder key", async () => {
+    conversationRow = makeConversation({
+      title: MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
+    });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload).toEqual({
+      requestedMessage: "Sure, here is the plan.",
+    });
+  });
+
+  // Only an exact key is a system constant. A title the user or the model
+  // wrote that happens to contain one is their copy and travels as written.
+  test("keeps a title that merely contains a message key", async () => {
+    conversationRow = makeConversation({
+      title: `notes on ${MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING}`,
+    });
+
+    await run();
+
+    expect(emitCalls[0].contextPayload.requestedTitle).toBe(
+      "notes on conversation.title.generating",
+    );
+  });
+
   test("caps the preview at 200 chars", async () => {
     assistantRow = makeAssistantRow([
       { type: "text", text: "a".repeat(300) },

package/src/notifications/__tests__/guardian-feed-projection.test.ts

@@ -39,15 +39,35 @@ mock.module("../../channels/gateway-guardian-requests.js", () => ({
   getGuardianRequest: (id: string) => getGuardianRequestStub(id),
 }));
 
+// The heal's completion sentinel lives in the daemon checkpoint ledger. An
+// in-memory map stands in so the heal runs without a database; it is cleared
+// per test so every test starts unhealed. The spread keeps the module's other
+// exports real for transitive importers.
+const actualCheckpoints = await import("../../persistence/checkpoints.js");
+const checkpointStore = new Map<string, string>();
+mock.module("../../persistence/checkpoints.js", () => ({
+  ...actualCheckpoints,
+  getMemoryCheckpoint: (key: string) => checkpointStore.get(key) ?? null,
+  setMemoryCheckpoint: (key: string, value: string) => {
+    checkpointStore.set(key, value);
+  },
+}));
+
 const {
   buildPendingGuardianProjection,
   guardianFeedItemId,
+  healLegacyGuardianReceiptUnread,
   reconcileGuardianFeedProjections,
   requestIdFromGuardianFeedItemId,
   writeGuardianFeedReceipt,
 } = await import("../guardian-feed-projection.js");
-const { appendFeedItem, bulkSetFeedItemStatus, getHomeFeedPath, readHomeFeed } =
-  await import("../../home/feed-writer.js");
+const {
+  appendFeedItem,
+  bulkSetFeedItemStatus,
+  getHomeFeedPath,
+  patchFeedItemStatus,
+  readHomeFeed,
+} = await import("../../home/feed-writer.js");
 const { GUARDIAN_TERMINAL_REASON_SUPERSEDED, isPendingGuardianFeedItem } =
   await import("../../api/responses/home.js");
 type FeedItem = import("../../api/responses/home.js").FeedItem;
@@ -61,6 +81,7 @@ beforeEach(() => {
   process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
   listGuardianRequestsStub = async () => [];
   getGuardianRequestStub = async () => null;
+  checkpointStore.clear();
 });
 
 afterEach(() => {
@@ -104,6 +125,72 @@ function pendingGuardianItem(requestId: string): FeedItem {
   };
 }
 
+/**
+ * A terminal receipt that never passed the pending-to-terminal edge:
+ * terminal projection, urgency `medium`, still `new`.
+ */
+function legacyGuardianReceiptItem(requestId: string): FeedItem {
+  const item = pendingGuardianItem(requestId);
+  return {
+    ...item,
+    urgency: "medium",
+    status: "new",
+    guardianRequest: { ...item.guardianRequest!, status: "approved" },
+  };
+}
+
+describe("healLegacyGuardianReceiptUnread", () => {
+  test("clears unread on a terminal receipt that never passed the edge", async () => {
+    await appendFeedItem(legacyGuardianReceiptItem("legacy-1"));
+
+    await healLegacyGuardianReceiptUnread();
+
+    expect(
+      readHomeFeed().items.find((i) => i.id === guardianFeedItemId("legacy-1"))
+        ?.status,
+    ).toBe("seen");
+  });
+
+  test("runs once per assistant, so a later mark-unread stands", async () => {
+    await appendFeedItem(legacyGuardianReceiptItem("legacy-2"));
+    const itemId = guardianFeedItemId("legacy-2");
+    await healLegacyGuardianReceiptUnread();
+
+    // The user marks the resolved receipt unread again. The pass has
+    // already recorded completion, so a second round leaves it alone.
+    await patchFeedItemStatus(itemId, "new");
+    await healLegacyGuardianReceiptUnread();
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "new",
+    );
+  });
+
+  test("never revives a dismissed receipt", async () => {
+    const item = legacyGuardianReceiptItem("legacy-3");
+    await appendFeedItem({ ...item, status: "dismissed" });
+
+    await healLegacyGuardianReceiptUnread();
+
+    expect(
+      readHomeFeed().items.find((i) => i.id === guardianFeedItemId("legacy-3"))
+        ?.status,
+    ).toBe("dismissed");
+  });
+
+  test("leaves a still-pending request alone", async () => {
+    await appendFeedItem(pendingGuardianItem("still-pending"));
+
+    await healLegacyGuardianReceiptUnread();
+
+    const item = readHomeFeed().items.find(
+      (i) => i.id === guardianFeedItemId("still-pending"),
+    );
+    expect(item?.status).toBe("new");
+    expect(item && isPendingGuardianFeedItem(item)).toBe(true);
+  });
+});
+
 describe("buildPendingGuardianProjection", () => {
   test("tool approval projects as a pending approval with source facts", () => {
     const projection = buildPendingGuardianProjection(toolApprovalPayload);
@@ -264,6 +351,75 @@ describe("writeGuardianFeedReceipt", () => {
     expect(item?.guardianRequest?.status).toBe("denied");
   });
 
+  test("a receipt stops the item reading as unread", async () => {
+    await appendFeedItem(pendingGuardianItem("req-6"));
+    await writeGuardianFeedReceipt({
+      requestId: "req-6",
+      status: "approved",
+      decidedAction: "approve_once",
+    });
+
+    const item = readHomeFeed().items.find(
+      (i) => i.id === guardianFeedItemId("req-6"),
+    );
+    // The clients' unread test is `status === "new"`, so a receipt left
+    // at `new` keeps lighting the bell for work nobody can act on.
+    expect(item?.status).toBe("seen");
+  });
+
+  test("a terminal status nobody decided also clears unread", async () => {
+    await appendFeedItem(pendingGuardianItem("req-7"));
+    await writeGuardianFeedReceipt({ requestId: "req-7", status: "expired" });
+
+    expect(
+      readHomeFeed().items.find((i) => i.id === guardianFeedItemId("req-7"))
+        ?.status,
+    ).toBe("seen");
+  });
+
+  test("a status the user set survives a re-run of the fan-out", async () => {
+    await appendFeedItem(pendingGuardianItem("req-8"));
+    const itemId = guardianFeedItemId("req-8");
+    await writeGuardianFeedReceipt({ requestId: "req-8", status: "approved" });
+    // The user clears the receipt, then the withdrawal fan-out retries
+    // (its per-request receipt is held back until every surface settles).
+    await patchFeedItemStatus(itemId, "dismissed");
+    await writeGuardianFeedReceipt({ requestId: "req-8", status: "approved" });
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "dismissed",
+    );
+  });
+
+  test("a pending request dismissed outright is not revived by its receipt", async () => {
+    await appendFeedItem(pendingGuardianItem("req-10"));
+    const itemId = guardianFeedItemId("req-10");
+    // Bulk dismissal spares a pending guardian item, but a deliberate
+    // single-item dismissal stays available and is not undone by the
+    // resolution that follows it.
+    await patchFeedItemStatus(itemId, "dismissed");
+    await writeGuardianFeedReceipt({ requestId: "req-10", status: "denied" });
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "dismissed",
+    );
+  });
+
+  test("a receipt the user marked unread again stays unread", async () => {
+    await appendFeedItem(pendingGuardianItem("req-9"));
+    const itemId = guardianFeedItemId("req-9");
+    await writeGuardianFeedReceipt({ requestId: "req-9", status: "approved" });
+    // The bell detail's read toggle writes `new` back onto a resolved
+    // receipt. The clear runs on the edge into terminal, which has
+    // already passed, so a later receipt must not take it back.
+    await patchFeedItemStatus(itemId, "new");
+    await writeGuardianFeedReceipt({ requestId: "req-9", status: "approved" });
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "new",
+    );
+  });
+
   test("a request with no item resolves true (nothing to retry)", async () => {
     expect(
       await writeGuardianFeedReceipt({ requestId: "ghost", status: "expired" }),

package/src/notifications/__tests__/home-feed-side-effect.test.ts

@@ -26,6 +26,15 @@ const messageRewrites: Array<{ messageId: string; content: string }> = [];
 /** messageId -> the conversation it belongs to, for the scoped lookup. */
 const messageOwners = new Map<string, string>();
 let conversationRow: { conversationType: string } | null = null;
+/**
+ * Rows for specific ids, consulted before the catch-all `conversationRow`,
+ * so a test can hand the signal's source and the delivery's paired
+ * conversation different shapes.
+ */
+const conversationRowsById = new Map<
+  string,
+  { conversationType: string; source?: string }
+>();
 let conversationLookupShouldThrow = false;
 let messageAppendShouldThrow = false;
 let messageRewriteShouldThrow = false;
@@ -71,7 +80,7 @@ mock.module("../../persistence/conversation-crud.js", () => ({
     if (conversationLookupShouldThrow) {
       throw new Error("simulated conversation lookup failure");
     }
-    return conversationRow;
+    return conversationRowsById.get(id) ?? conversationRow;
   },
   addMessage: async (
     conversationId: string,
@@ -164,6 +173,7 @@ beforeEach(() => {
   messageRewrites.length = 0;
   messageOwners.clear();
   conversationRow = null;
+  conversationRowsById.clear();
   conversationLookupShouldThrow = false;
   messageAppendShouldThrow = false;
   messageRewriteShouldThrow = false;
@@ -258,7 +268,11 @@ describe("writeHomeFeedItemForSignal", () => {
       },
     });
 
-    const item = await writeHomeFeedItemForSignal(signal, decision);
+    const item = await writeHomeFeedItemForSignal(
+      signal,
+      decision,
+      makeVellumDelivery(),
+    );
 
     expect(item).not.toBeNull();
     expect(appendCalls).toHaveLength(1);
@@ -267,7 +281,10 @@ describe("writeHomeFeedItemForSignal", () => {
       "The deployment completed successfully.",
     );
     expect(appendCalls[0]!.conversationId).toBe("conv-source-1");
-    expect(conversationLookups).toEqual(["conv-source-1"]);
+    expect(appendCalls[0]!.metadata?.notificationConversationMessageId).toBeUndefined();
+    expect(messageAppends).toEqual([]);
+    expect(messagesInvalidated).toEqual([]);
+    expect(conversationLookups).toEqual(["conv-source-1", "conv-source-1"]);
   });
 
   test("isAsyncBackground hint writes even when sourceContextId does not resolve", async () => {
@@ -402,6 +419,139 @@ describe("writeHomeFeedItemForSignal", () => {
     expect(appendCalls[0]!.conversationId).toBe("paired-delivery-conv-id");
   });
 
+  describe("assistant-initiated thread deliveries", () => {
+    // Under the assistant-initiated-threads flag, conversation pairing
+    // promotes a background assistant.share into a standard conversation
+    // stamped `assistant_initiated`, which the sidebar's assistant section
+    // renders. That thread is the share's surface; a feed item for the
+    // same signal put it in the bell a second time.
+    const assistantThreadDelivery = () =>
+      makeVellumDelivery({ conversationId: "assistant-thread-1" });
+
+    function stampAssistantThread(): void {
+      conversationRowsById.set("assistant-thread-1", {
+        conversationType: "standard",
+        source: "assistant_initiated",
+      });
+    }
+
+    function shareFromHeartbeat(): NotificationSignal {
+      return makeSignal({
+        sourceChannel: "assistant_tool",
+        sourceEventName: "assistant.share",
+        sourceContextId: "conv-source-1",
+        contextPayload: { title: "Doctor checklist built" },
+      });
+    }
+
+    const shareDecision = () =>
+      makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: {
+            title: "Doctor checklist built",
+            body: "Your doctor-visit one-pager is ready.",
+          },
+        },
+      });
+
+    test("a background share promoted into an assistant thread does not mirror", async () => {
+      conversationRow = { conversationType: "background" };
+      stampAssistantThread();
+
+      const item = await writeHomeFeedItemForSignal(
+        shareFromHeartbeat(),
+        shareDecision(),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).toBeNull();
+      expect(appendCalls).toHaveLength(0);
+      expect(messageAppends).toHaveLength(0);
+    });
+
+    test("the async-background hint does not override the assistant-thread suppression", async () => {
+      conversationRow = null;
+      stampAssistantThread();
+      const signal = makeSignal({
+        sourceChannel: "assistant_tool",
+        sourceEventName: "assistant.share",
+        sourceContextId: "heartbeat",
+        contextPayload: { title: "Bilbao solo trip is planned" },
+        attentionHints: {
+          requiresAction: false,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        shareDecision(),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).toBeNull();
+      expect(appendCalls).toHaveLength(0);
+    });
+
+    test("a share paired with an ordinary notification thread still mirrors", async () => {
+      // Flag off, or any producer that did not promote: pairing writes a
+      // `notification`-sourced row, which stays in Chats and the bell.
+      conversationRow = { conversationType: "background" };
+      conversationRowsById.set("assistant-thread-1", {
+        conversationType: "standard",
+        source: "notification",
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        shareFromHeartbeat(),
+        shareDecision(),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).not.toBeNull();
+      expect(appendCalls).toHaveLength(1);
+    });
+
+    test("a guardian request keeps its bell item even when paired with an assistant thread", async () => {
+      // The bell is the request's canonical home: nothing else renders the
+      // pending card, so the assistant-thread suppression must not reach it.
+      conversationRow = { conversationType: "standard" };
+      stampAssistantThread();
+      const signal = makeSignal({
+        sourceChannel: "assistant_tool",
+        sourceEventName: "guardian.question",
+        contextPayload: {
+          title: "Approve this?",
+          questionText: "May I send the email?",
+          requestId: "req-1",
+        },
+        attentionHints: {
+          requiresAction: true,
+          urgency: "medium",
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        makeDecision({
+          selectedChannels: ["vellum"],
+          renderedCopy: {
+            vellum: { title: "Approve this?", body: "May I send the email?" },
+          },
+        }),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).not.toBeNull();
+      expect(appendCalls).toHaveLength(1);
+    });
+  });
+
   test("source conversation id wins over the paired delivery fallback when both are available", async () => {
     // When the producer's `sourceContextId` already points at a real
     // conversation (the canonical "where the work happened"), prefer it

package/src/notifications/__tests__/schedule-result-producer.test.ts

@@ -55,6 +55,13 @@ const SCHEDULE_ID = "sched-1";
 const RUN_ID = "run-1";
 const RUN_STARTED_AT = 1700000000000;
 
+/**
+ * The synthetic user rows carrying each tool call's result. A delivery counts
+ * only when its call reported success, so a case that wants suppression has to
+ * supply the matching successful result.
+ */
+let toolResultRows: MessageRow[] = [];
+
 const realCrud = await import("../../persistence/conversation-crud.js");
 mock.module("../../persistence/conversation-crud.js", () => ({
   ...realCrud,
@@ -66,6 +73,7 @@ mock.module("../../persistence/conversation-crud.js", () => ({
     messageId === ASSISTANT_MESSAGE_ID
       ? [...turnRows.map((row) => row.id), ASSISTANT_MESSAGE_ID]
       : [messageId],
+  getMessagesAfter: () => toolResultRows,
 }));
 
 const realAttentionStore =
@@ -114,6 +122,25 @@ function makeToolCallRow(
   );
 }
 
+/** The executor's verdict on the call `makeToolCallRow(name, ...)` made. */
+function makeToolResultRow(name: string, isError = false): MessageRow {
+  return makeAssistantRow(
+    [
+      {
+        type: "tool_result",
+        tool_use_id: `tu-${name}`,
+        content: isError ? "failed" : "ok",
+        ...(isError ? { is_error: true } : {}),
+      },
+    ] as ContentBlock[],
+    {
+      id: `res-${name}`,
+      role: "user",
+      createdAt: RUN_STARTED_AT + 150,
+    },
+  );
+}
+
 function makeAttentionState(
   overrides: Partial<AttentionState> = {},
 ): AttentionState {
@@ -189,6 +216,7 @@ beforeEach(() => {
   notifiedProbeArgs.length = 0;
   alreadyNotified = false;
   turnRows = [];
+  toolResultRows = [];
   attentionState = makeAttentionState();
   assistantRow = makeAssistantRow([
     { type: "text", text: "**3 new emails** and one calendar change." },
@@ -245,7 +273,8 @@ describe("emitScheduleResultNotification", () => {
 
   test("stays silent when the run delivered by email through messaging_send", async () => {
     // The schedule skill's prescribed route for rich content. It writes no
-    // notification event, so only the tool call shows the user has the result.
+    // notification event, so the successful tool call is what shows the user
+    // has the result.
     turnRows = [
       makeToolCallRow("messaging_send", {
         platform: "gmail",
@@ -253,6 +282,7 @@ describe("emitScheduleResultNotification", () => {
         message: "Inbox digest…",
       }),
     ];
+    toolResultRows = [makeToolResultRow("messaging_send")];
     assistantRow = makeAssistantRow([
       { type: "text", text: "Sent the digest to your inbox." },
     ] as ContentBlock[]);
@@ -262,20 +292,86 @@ describe("emitScheduleResultNotification", () => {
     expect(emitCalls).toHaveLength(0);
   });
 
-  test("stays silent when the run posted to Slack through chat.postMessage", async () => {
+  test("stays silent when the run posted to a channel through messaging_send", async () => {
+    turnRows = [
+      makeToolCallRow("messaging_send", {
+        platform: "slack",
+        conversation_id: "C0123456789",
+        text: "the digest",
+      }),
+    ];
+    toolResultRows = [makeToolResultRow("messaging_send")];
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "Posted the digest to #general." },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("notifies when the channel send failed, so the run is not silent", async () => {
+    // The failure this guard exists for: the post never landed, the run said
+    // so in a conversation nobody has open, and suppressing on the attempt
+    // would cost the user the digest and the explanation both.
+    turnRows = [
+      makeToolCallRow("messaging_send", {
+        platform: "slack",
+        conversation_id: "C0123456789",
+        text: "the digest",
+      }),
+    ];
+    toolResultRows = [makeToolResultRow("messaging_send", true)];
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "I could not post the digest to #general." },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload.requestedMessage).toBe(
+      "I could not post the digest to #general.",
+    );
+  });
+
+  test("notifies when a delivery call left no result at all", async () => {
+    // An interrupted turn persists the call without its verdict. Unproven is
+    // not delivered.
+    turnRows = [
+      makeToolCallRow("messaging_send", {
+        platform: "slack",
+        conversation_id: "C0123456789",
+        text: "the digest",
+      }),
+    ];
+    toolResultRows = [];
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "Here is the digest." },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+  });
+
+  test("notifies after a Web API post, whose success cannot prove Slack accepted it", async () => {
+    // Slack refuses a call with HTTP 200 and `ok: false`, so a successful bash
+    // result is no evidence the post landed. This is the best case the route
+    // can produce, and it still gets the fallback.
     turnRows = [
       makeToolCallRow("bash", {
         command:
           'assistant oauth request --provider slack_channel /chat.postMessage --json \'{"channel":"C1","text":"digest"}\'',
       }),
     ];
+    toolResultRows = [makeToolResultRow("bash")];
     assistantRow = makeAssistantRow([
       { type: "text", text: "Posted the digest to #general." },
     ] as ContentBlock[]);
 
     await run();
 
-    expect(emitCalls).toHaveLength(0);
+    expect(emitCalls).toHaveLength(1);
   });
 
   test("still notifies when the run's tool calls were not deliveries", async () => {

package/src/notifications/adapters/macos.ts

@@ -20,6 +20,7 @@
 
 import type { AssistantEvent } from "../../api/index.js";
 import type { InterfaceId } from "../../channels/types.js";
+import { getAssistantName } from "../../daemon/identity-helpers.js";
 import { updateMessageContent } from "../../persistence/conversation-crud.js";
 import { publishConversationMessagesChanged } from "../../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../../util/logger.js";
@@ -101,12 +102,14 @@ export class VellumAdapter implements ChannelAdapter {
 
       const silent =
         payload.urgency !== "high" && payload.urgency !== "critical";
+      const assistantName = getAssistantName()?.trim() || undefined;
 
       this.broadcast({
         type: "notification_intent",
         deliveryId: payload.deliveryId,
         correlationId: payload.correlationId,
         sourceEventName: payload.sourceEventName,
+        ...(assistantName ? { assistantName } : {}),
         title: payload.copy.title,
         body: payload.copy.body,
         deepLinkMetadata: payload.deepLinkTarget,

package/src/notifications/assistant-reply-producer.ts

@@ -22,6 +22,7 @@ import {
   getMessageById,
   parseMessageMetadata,
 } from "../persistence/conversation-crud.js";
+import { isReplaceableTitle } from "../persistence/conversation-title-placeholders.js";
 import {
   isDesktopOriginatedUserMessage,
   isReplyPushIneligibleUserMessage,
@@ -247,9 +248,13 @@ export async function emitAssistantReplyNotification(params: {
     // lock screen. Absent `requestedTitle` lets the decision branch derive a
     // title from the body, which reads better than an empty or placeholder
     // conversation title.
-    const requestedTitle = sanitizeNotificationTitle(
-      flattenTitleWhitespace(conversation.title ?? ""),
-    );
+    //
+    // Placeholder titles are plausible non-empty strings and survive
+    // sanitizing. They count as absent so the body supplies the title instead.
+    const storedTitle = conversation.title?.trim() ?? "";
+    const requestedTitle = isReplaceableTitle(storedTitle)
+      ? ""
+      : sanitizeNotificationTitle(flattenTitleWhitespace(storedTitle));
 
     // Read as close to the emit as possible: nothing short-circuits on it.
     // Presence only speaks for a turn the desktop itself opened, on that row's