@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/notifications/__tests__/emit-signal-pipeline-failure.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Regression tests for what a failed emit leaves behind in the events store.
+ *
+ * `createEvent` claims the producer's dedupe key as its first pipeline step.
+ * A failure after that point releases the claim, so the retry is not
+ * short-circuited as "deduplicated at event store level" by an emit that
+ * never reached a verdict. A completed emit keeps its claim so real
+ * duplicates still collapse.
+ *
+ * A failure that already reached a channel keeps its claim too: the retry
+ * would broadcast under a fresh decision id, and delivery dedupe is keyed to
+ * the decision, so every channel that already went out would go out twice.
+ *
+ * The events store, its DB, and the deterministic checks are the real ones;
+ * only the decision engine, the dispatch step, and the adapter graph around
+ * them are stubbed.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const dispatchDecisionMock = mock();
+
+mock.module("../../channels/config.js", () => ({
+  getDeliverableChannels: () => ["vellum"],
+}));
+
+mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [],
+  guardianForChannel: () => undefined,
+}));
+
+mock.module("../../platform/client.js", () => ({
+  VellumPlatformClient: class {
+    static async create(): Promise<null> {
+      return null;
+    }
+  },
+  isPlatformClientConfigured: async () => false,
+}));
+
+mock.module("../broadcaster.js", () => ({
+  NotificationBroadcaster: class {
+    constructor(_adapters: unknown[]) {}
+    setOnConversationCreated(_fn: unknown) {}
+  },
+}));
+
+const DEDUPE_KEY = "schedule-definition-error:plugin:news/digest:2026-01-01";
+
+mock.module("../decision-engine.js", () => ({
+  evaluateSignal: async () => ({
+    shouldNotify: true,
+    selectedChannels: ["vellum"],
+    reasoningSummary: "deliver",
+    renderedCopy: {
+      vellum: { title: "Plugin schedule error", body: "digest failed to load" },
+    },
+    dedupeKey: DEDUPE_KEY,
+    confidence: 0.9,
+    fallbackUsed: false,
+  }),
+  enforceRoutingIntent: (decision: unknown) => decision,
+}));
+
+mock.module("../decisions-store.js", () => ({
+  updateDecision: () => {},
+}));
+
+mock.module("../home-feed-side-effect.js", () => ({
+  writeHomeFeedItemForSignal: async () => {},
+}));
+
+mock.module("../runtime-dispatch.js", () => ({
+  dispatchDecision: (...args: unknown[]) => dispatchDecisionMock(...args),
+}));
+
+import { getDb } from "../../persistence/db-connection.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import { notificationEvents } from "../../persistence/schema/index.js";
+import type { EmitSignalParams } from "../emit-signal.js";
+import type { NotificationDeliveryResult } from "../types.js";
+
+await initializeDb();
+
+const { emitNotificationSignal } = await import("../emit-signal.js");
+
+function emit() {
+  const params: EmitSignalParams<string> = {
+    sourceEventName: "schedule.definition_error",
+    sourceChannel: "scheduler",
+    sourceContextId: "plugin:news/digest",
+    dedupeKey: DEDUPE_KEY,
+    contextPayload: { pluginName: "news", scheduleName: "digest" },
+    attentionHints: {
+      requiresAction: false,
+      urgency: "medium",
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+  };
+  return emitNotificationSignal(params);
+}
+
+/**
+ * Stub one dispatch as a broadcast that settles the given channels and then
+ * throws on a later channel's prep. What already happened leaves the
+ * broadcast through the results sink; the return value dies with the throw.
+ */
+function throwAfterChannels(...settled: NotificationDeliveryResult[]): void {
+  dispatchDecisionMock.mockImplementationOnce(
+    (
+      _signal: unknown,
+      _decision: unknown,
+      _broadcaster: unknown,
+      options: { resultsSink?: NotificationDeliveryResult[] },
+    ) => {
+      options.resultsSink?.push(...settled);
+      throw new Error("conversation pairing failed for a later channel");
+    },
+  );
+}
+
+beforeEach(() => {
+  getDb().delete(notificationEvents).run();
+  dispatchDecisionMock.mockReset();
+  dispatchDecisionMock.mockResolvedValue({
+    dispatched: true,
+    reason: "Dispatched to 1/1 channels",
+    deliveryResults: [],
+  });
+});
+
+describe("emitNotificationSignal dedupe claim on failure", () => {
+  test("a retry after a mid-pipeline failure dispatches", async () => {
+    dispatchDecisionMock.mockRejectedValueOnce(new Error("transient outage"));
+
+    const failed = await emit();
+    expect(failed.pipelineFailed).toBe(true);
+    expect(failed.dispatched).toBe(false);
+
+    const retried = await emit();
+    expect(retried.pipelineFailed).toBe(false);
+    expect(retried.deduplicated).toBe(false);
+    expect(retried.dispatched).toBe(true);
+
+    // The failed attempt keeps its row for the audit trail; only its claim on
+    // the dedupe key is released.
+    const rows = getDb().select().from(notificationEvents).all();
+    expect(rows).toHaveLength(2);
+    expect(rows.find((r) => r.id === failed.signalId)?.dedupeKey).toBeNull();
+    expect(rows.find((r) => r.id === retried.signalId)?.dedupeKey).toBe(
+      DEDUPE_KEY,
+    );
+  });
+
+  // "sent" is a completed channel delivery; "pending" is the platform push
+  // that passed its outcome deadline and is still in flight. Both are
+  // side effects a retry would repeat.
+  for (const status of ["sent", "pending"] as const) {
+    test(`a failure after a ${status} channel keeps its dedupe key`, async () => {
+      throwAfterChannels({
+        channel: "vellum",
+        destination: "vellum",
+        status,
+      });
+
+      const partial = await emit();
+      expect(partial.pipelineFailed).toBe(true);
+
+      const retried = await emit();
+      expect(retried.deduplicated).toBe(true);
+      expect(retried.dispatched).toBe(false);
+      expect(dispatchDecisionMock).toHaveBeenCalledTimes(1);
+
+      const rows = getDb().select().from(notificationEvents).all();
+      expect(rows).toHaveLength(1);
+      expect(rows[0]!.dedupeKey).toBe(DEDUPE_KEY);
+    });
+  }
+
+  test("a failure after only skipped and failed channels releases its key", async () => {
+    throwAfterChannels(
+      { channel: "slack", destination: "slack", status: "skipped" },
+      { channel: "telegram", destination: "telegram", status: "failed" },
+    );
+
+    const failed = await emit();
+    expect(failed.pipelineFailed).toBe(true);
+
+    const retried = await emit();
+    expect(retried.deduplicated).toBe(false);
+    expect(retried.dispatched).toBe(true);
+  });
+
+  test("a completed emit keeps its dedupe key, so a repeat is deduplicated", async () => {
+    const first = await emit();
+    expect(first.dispatched).toBe(true);
+
+    const second = await emit();
+    expect(second.deduplicated).toBe(true);
+    expect(second.dispatched).toBe(false);
+    expect(second.pipelineFailed).toBe(false);
+    expect(dispatchDecisionMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/notifications/__tests__/notification-utils.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  describeMedia,
+  mediaEmbeds,
+  stripMarkdownForPreview,
+} from "../notification-utils.js";
+
+/**
+ * The producer collapses whitespace after flattening, so most assertions read
+ * the flattened text the way a lock screen would.
+ */
+function preview(value: string): string {
+  return stripMarkdownForPreview(value).replace(/\s+/g, " ").trim();
+}
+
+describe("stripMarkdownForPreview", () => {
+  describe("media embeds", () => {
+    test("drops an embed whole, alt text included", () => {
+      expect(
+        preview("![vellum scene](vellum://workspace/clients/vellum-cut.mp4)"),
+      ).toBe("");
+    });
+
+    test("reduces an embed-only reply to empty so the fallback is reachable", () => {
+      const reply = [
+        "![vellum scene](vellum://workspace/clients/web/public/cut.mp4)",
+        "![hero animation](vellum://workspace/repos/hero.mp4)",
+      ].join(" ");
+      expect(preview(reply)).toBe("");
+    });
+
+    test("keeps the surrounding prose", () => {
+      expect(
+        preview("Here is the scene: ![vellum scene](vellum://workspace/a.mp4)"),
+      ).toBe("Here is the scene:");
+    });
+
+    test("leaves no stray bang behind", () => {
+      expect(preview("![alt](vellum://workspace/a.png)")).not.toContain("!");
+    });
+
+    // An embed needs no surrounding whitespace, so dropping it outright would
+    // fuse the prose on either side into one word.
+    test("separates the prose an inline embed sat between", () => {
+      expect(preview("before![chart](https://example.com/a.png)after")).toBe(
+        "before after",
+      );
+    });
+
+    test("unwraps a plain link to its text", () => {
+      expect(preview("See [report.pdf](vellum://workspace/report.pdf)")).toBe(
+        "See report.pdf",
+      );
+    });
+  });
+
+  // Fenced content is code, not prose. Flattening it would rewrite the very
+  // thing being previewed.
+  describe("fenced code", () => {
+    test("drops fence lines and keeps the fenced code", () => {
+      expect(preview("Fixed it:\n```ts\nconst a = 1;\n```")).toBe(
+        "Fixed it: const a = 1;",
+      );
+    });
+
+    test("leaves a comment inside a fence with its hash", () => {
+      expect(preview("Run:\n```sh\n# build first\nmake\n```")).toBe(
+        "Run: # build first make",
+      );
+    });
+
+    test("leaves a rule and a piped expression inside a fence alone", () => {
+      expect(preview("```sh\n---\n| a | b |\n```")).toBe("--- | a | b |");
+    });
+
+    test("still flattens prose after the closing fence", () => {
+      expect(preview("```\ncode\n```\n## After")).toBe("code After");
+    });
+  });
+
+  describe("block markers", () => {
+    test("drops heading markers", () => {
+      expect(preview("## Summary\nAll green.")).toBe("Summary All green.");
+    });
+
+    test("drops blockquote markers", () => {
+      expect(preview("> quoted line")).toBe("quoted line");
+    });
+
+    test("drops unordered and ordered list markers", () => {
+      expect(preview("- one\n- two")).toBe("one two");
+      expect(preview("1. first\n2) second")).toBe("first second");
+    });
+
+    test("drops horizontal rules", () => {
+      expect(preview("before\n---\nafter")).toBe("before after");
+    });
+  });
+
+  describe("tables", () => {
+    test("unwraps cells and drops the delimiter row", () => {
+      const table = "| Env | Key |\n|---|---|\n| dev | 4Y4L |";
+      expect(preview(table)).toBe("Env Key dev 4Y4L");
+    });
+
+    test("leaves a pipe in prose alone", () => {
+      expect(preview("run ls | grep foo")).toBe("run ls | grep foo");
+    });
+  });
+
+  // Cases a hand-rolled marker scanner gets wrong and the parser gets right.
+  describe("syntax that needs a real parser", () => {
+    test("reads a destination whose URL has balanced parentheses", () => {
+      expect(preview("![chart](https://cdn.example.com/a_(1).png)")).toBe("");
+    });
+
+    test("closes a fence only on its own delimiter", () => {
+      expect(preview("```js\n~~~\nconst a = 1;\n~~~\n```")).toBe(
+        "~~~ const a = 1; ~~~",
+      );
+    });
+
+    test("flattens a GFM table that omits its outer pipes", () => {
+      expect(preview("Env | Key\n--- | ---\ndev | 4Y4L")).toBe(
+        "Env Key dev 4Y4L",
+      );
+    });
+
+    test("keeps embed syntax quoted inside a code span", () => {
+      expect(preview("Use `![alt](https://example.com/a.png)` here")).toBe(
+        "Use ![alt](https://example.com/a.png) here",
+      );
+    });
+
+    test("keeps escaped embed syntax", () => {
+      expect(preview("\\![alt](https://example.com/a.png)")).toContain("alt");
+    });
+  });
+
+  // The in-app renderer registers no `rehype-raw`, so raw HTML displays as
+  // nothing there. The preview matches rather than showing markup the reader
+  // never saw.
+  describe("raw HTML", () => {
+    test("keeps the text between a tag pair and drops the tags", () => {
+      expect(preview("<strong>done</strong>")).toBe("done");
+    });
+
+    test("drops an HTML comment rather than leaking its contents", () => {
+      expect(preview("<!-- internal note -->")).toBe("");
+    });
+
+    test("keeps the prose around a dropped tag", () => {
+      expect(preview("All <em>green</em> now")).toBe("All green now");
+    });
+  });
+
+  describe("what it must not touch", () => {
+    test("passes plain prose through unchanged", () => {
+      const prose = "Done. The deploy finished and the tests are green.";
+      expect(stripMarkdownForPreview(prose)).toBe(prose);
+    });
+
+    test("preserves line structure for multi-line callers", () => {
+      expect(stripMarkdownForPreview("first\n\nsecond")).toContain("\n");
+    });
+
+    test("returns empty for empty input", () => {
+      expect(stripMarkdownForPreview("")).toBe("");
+    });
+  });
+});
+
+describe("mediaEmbeds", () => {
+  const alts = (value: string): string[] =>
+    mediaEmbeds(value).map((embed) => embed.alt);
+
+  test("recovers the alts a flattened reply dropped", () => {
+    expect(
+      alts(
+        "![the Q3 chart](https://cdn.example.com/q3.png) ![scene](vellum://workspace/a.mp4)",
+      ),
+    ).toEqual(["the Q3 chart", "scene"]);
+  });
+
+  test("keeps an empty alt as a placeholder rather than dropping it", () => {
+    expect(alts("![](https://cdn.example.com/a.png)")).toEqual([""]);
+  });
+
+  test("ignores plain links", () => {
+    expect(alts("[report.pdf](vellum://workspace/r.pdf)")).toEqual([]);
+  });
+
+  test("returns nothing for prose", () => {
+    expect(alts("Done, all green.")).toEqual([]);
+  });
+
+  // The parser resolves an image description to plain text, so a formatted alt
+  // cannot reintroduce the markdown this module exists to remove.
+  test("returns a formatted alt already flattened", () => {
+    expect(alts("![**chart**](https://example.com/a.png)")).toEqual(["chart"]);
+  });
+
+  test("ignores embed syntax quoted inside a code span", () => {
+    expect(alts("Use `![alt](https://example.com/a.png)` here")).toEqual([]);
+  });
+
+  // Only untracked embeds need naming from their alt: a caller holding
+  // attachment metadata has already counted the tracked ones.
+  describe("tracking", () => {
+    test("marks workspace and host destinations tracked", () => {
+      expect(
+        mediaEmbeds(
+          "![a](vellum://workspace/a.mp4) ![b](vellum://host/tmp/b.png)",
+        ).map((embed) => embed.tracked),
+      ).toEqual([true, true]);
+    });
+
+    test("marks a remote destination untracked", () => {
+      expect(
+        mediaEmbeds("![a](https://cdn.example.com/a.png)")[0]?.tracked,
+      ).toBe(false);
+    });
+
+    test("marks a reference embed untracked", () => {
+      expect(
+        mediaEmbeds("![a][ref]\n\n[ref]: vellum://workspace/a.png")[0]?.tracked,
+      ).toBe(false);
+    });
+  });
+});
+
+describe("describeMedia", () => {
+  test("names a single label", () => {
+    expect(describeMedia(["cut.mp4"])).toBe("Sent cut.mp4");
+  });
+
+  test("counts several rather than listing them", () => {
+    expect(describeMedia(["a.png", "b.png"])).toBe("Sent 2 attachments");
+  });
+
+  test("falls back to generic copy for a label that sanitizes away", () => {
+    expect(describeMedia(["\0\x07"])).toBe("Sent an attachment");
+  });
+
+  test("returns empty for no labels, leaving the fallback to the caller", () => {
+    expect(describeMedia([])).toBe("");
+  });
+});

package/src/notifications/adapters/platform.ts

@@ -18,6 +18,11 @@ import {
   isRetryableStatus,
   sleep,
 } from "../../util/retry.js";
+import {
+  describeMedia,
+  mediaEmbeds,
+  stripMarkdownForPreview,
+} from "../notification-utils.js";
 import type {
   ChannelAdapter,
   ChannelDeliveryObserver,
@@ -38,6 +43,30 @@ const RETRY_DELAYS_MS = [250, 1_000, 4_000] as const;
 // dispatch's outcome -- a hung platform must fail the attempt, not stall it.
 const ATTEMPT_TIMEOUT_MS = 5_000;
 
+/**
+ * Flatten one alert field for a plain-text surface, recovering copy when
+ * flattening leaves nothing behind.
+ *
+ * An APNs/FCM alert renders no markdown, so markers arrive as literal
+ * punctuation. Flattening here covers every event routed to this channel
+ * without altering what other channels receive, some of which render markdown
+ * deliberately. Newlines survive: iOS renders them, and guardian copy carries a
+ * deliberate paragraph break.
+ *
+ * The recovery is load-bearing rather than cosmetic. Copy composed entirely of
+ * media embeds, which the pass-through path copies into both the title and the
+ * body, flattens to nothing, and the pipeline's empty-copy guards all run
+ * upstream of this adapter. The platform's serializer rejects a blank title,
+ * so an unrecovered field costs the whole notification, not just its wording.
+ */
+function flattenAlertField(value: string): string {
+  const flattened = stripMarkdownForPreview(value);
+  if (flattened.trim().length > 0) {
+    return flattened;
+  }
+  return describeMedia(mediaEmbeds(value).map((embed) => embed.alt)) || value;
+}
+
 /** Whether a fetch error is the per-attempt abort timeout firing. */
 function isAttemptTimeout(err: unknown): boolean {
   const name = (err as { name?: unknown } | null)?.name;
@@ -108,8 +137,8 @@ export class PlatformPushAdapter implements ChannelAdapter {
     const body: DispatchBody = {
       delivery_id: payload.correlationId ?? payload.deliveryId,
       source_event_name: payload.sourceEventName,
-      title: payload.copy.title,
-      body: payload.copy.body,
+      title: flattenAlertField(payload.copy.title),
+      body: flattenAlertField(payload.copy.body),
       deep_link_metadata: payload.deepLinkTarget,
       context_payload: payload.contextPayload,
       target_guardian_principal_id: targetGuardianPrincipalId,

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

@@ -23,20 +23,28 @@ import {
   parseMessageMetadata,
 } from "../persistence/conversation-crud.js";
 import {
+  isMacOriginatedUserMessage,
   isReplyPushIneligibleUserMessage,
   resolveConversationKind,
 } from "../persistence/conversation-types.js";
 import { stringifyMessageContent } from "../persistence/message-content.js";
+import { isDesktopAttended } from "../runtime/desktop-presence.js";
 import { safeParseRecord } from "../util/json.js";
 import { emitNotificationSignal } from "./emit-signal.js";
 import {
+  describeMedia,
+  mediaEmbeds,
   sanitizeMessagePreview,
   sanitizeNotificationTitle,
+  stripMarkdownForPreview,
 } from "./notification-utils.js";
 
 /** Kill switch for this producer, on by default. */
 const ASSISTANT_REPLY_PUSH_FLAG = "assistant-reply-push" as const;
 
+/** Gates the desktop-attended suppression below, on by default. */
+const DESKTOP_PRESENCE_FLAG = "desktop-presence-suppression" as const;
+
 /**
  * Collapse whitespace runs ahead of the sanitizers' truncation: blank lines and
  * list indentation would otherwise eat into the copy's length budget.
@@ -46,31 +54,42 @@ function collapseWhitespace(value: string): string {
 }
 
 /**
- * Body for a reply whose only user-visible output is attachments. Generated
- * files and images are linked to the assistant row by
- * `resolveAssistantAttachments` before the turn's terminal SSE, and are
- * exposed separately from the row's content blocks, so a file-generation reply
- * reaches this producer with no text to preview. Reads attachment metadata
- * only (no base64), and only once the text preview has already come up empty.
+ * Body naming every piece of media a reply produced, for a reply whose text
+ * flattened away.
+ *
+ * Two sources, counted together so a reply mixing them is not undercounted.
+ * Attachment rows cover generated files, `<vellum-attachment />` directives,
+ * and `vellum://` embeds alike; they are linked to the assistant row by
+ * `resolveAssistantAttachments` before the turn's terminal SSE and exposed
+ * separately from its content blocks. Remote embeds leave no row, so their alt
+ * text is the only label they have.
  *
- * Returns an empty string when the row has no attachments either, which is the
- * genuinely-empty reply the caller suppresses.
+ * Tracked embeds are dropped from the second source rather than added twice:
+ * a `vellum://` embed is already one of the attachment rows.
+ *
+ * Reads attachment metadata only (no base64), and the caller invokes this only
+ * once the text preview has come up empty.
  */
-function describeAttachmentOnlyReply(assistantMessageId: string): string {
-  const attachments = getAttachmentMetadataForMessage(assistantMessageId);
-  if (attachments.length === 0) {
-    return "";
-  }
-  if (attachments.length > 1) {
-    return `Sent ${attachments.length} attachments`;
-  }
-  // Filenames are model- and tool-authored, so one is sanitized before it can
-  // reach the lock screen. A filename that sanitizes away leaves generic copy
-  // rather than a dangling "Sent ".
-  const filename = sanitizeMessagePreview(
-    collapseWhitespace(attachments[0].originalFilename),
+function describeReplyMedia(text: string, assistantMessageId: string): string {
+  const filenames = getAttachmentMetadataForMessage(assistantMessageId).map(
+    (attachment) => attachment.originalFilename,
   );
-  return filename ? `Sent ${filename}` : "Sent an attachment";
+  const embeds = mediaEmbeds(text);
+  const tracked = embeds.filter((embed) => embed.tracked);
+
+  // Resolution is allowed to fail: `resolveAssistantAttachments` skips a file
+  // that is missing, oversized, unreadable, or denied at the host-read
+  // approval, leaving a tracked embed with no row to stand for it. Rows at
+  // least matching the tracked embeds means each one resolved (any surplus
+  // being generated files); a shortfall is that many embeds falling back to
+  // their own alt rather than vanishing from the count.
+  const unresolved = Math.max(0, tracked.length - filenames.length);
+
+  return describeMedia([
+    ...filenames,
+    ...tracked.slice(tracked.length - unresolved).map((embed) => embed.alt),
+    ...embeds.filter((embed) => !embed.tracked).map((embed) => embed.alt),
+  ]);
 }
 
 /**
@@ -93,6 +112,23 @@ function readSuppressionMarkers(
   return metadataJson ? safeParseRecord(metadataJson) : undefined;
 }
 
+/**
+ * Desktop attendance, kept fail-open here: a presence read that fails has to
+ * send the push, not reach the producer's catch and silence it.
+ *
+ * No `actorPrincipalId`: the platform delivers this push to the assistant
+ * owner's device tokens, and a pod has exactly one owner, so any attended
+ * macOS client is that owner's.
+ */
+function readDesktopAttended(rlog: pino.Logger): boolean {
+  try {
+    return isDesktopAttended();
+  } catch (err) {
+    rlog.warn({ err }, "Desktop presence read failed; treating as unattended");
+    return false;
+  }
+}
+
 export async function emitAssistantReplyNotification(params: {
   conversationId: string;
   assistantMessageId: string;
@@ -161,14 +197,16 @@ export async function emitAssistantReplyNotification(params: {
       return;
     }
 
-    // A reply whose output is entirely attachments has no text to preview, so
-    // fall back to naming them rather than suppressing a real reply. A reply
-    // with neither text nor attachments stays silent.
+    // A reply whose output is entirely media has no text to preview, so name
+    // the media rather than suppressing a real reply. Markdown is flattened
+    // first: a lock screen renders none of it, and an embed-only reply has to
+    // reduce to empty for the fallback to be reachable. A reply with neither
+    // text nor media stays silent.
+    const text = stringifyMessageContent(assistantRow.content);
     const preview =
       sanitizeMessagePreview(
-        collapseWhitespace(stringifyMessageContent(assistantRow.content)),
-      ) ||
-      sanitizeMessagePreview(describeAttachmentOnlyReply(assistantMessageId));
+        collapseWhitespace(stripMarkdownForPreview(text)),
+      ) || sanitizeMessagePreview(describeReplyMedia(text, assistantMessageId));
     if (!preview) {
       return;
     }
@@ -182,6 +220,15 @@ export async function emitAssistantReplyNotification(params: {
       collapseWhitespace(conversation.title ?? ""),
     );
 
+    // Read as close to the emit as possible: nothing short-circuits on it.
+    // Presence only speaks for a turn the Mac itself opened, on that row's own
+    // OS evidence. A turn sent from the phone still needs its push while the
+    // Mac sits idle within the desktop client's attendance window.
+    const desktopAttended =
+      isAssistantFeatureFlagEnabled(DESKTOP_PRESENCE_FLAG) &&
+      isMacOriginatedUserMessage(initiatingMetadata) &&
+      readDesktopAttended(rlog);
+
     await emitNotificationSignal({
       sourceEventName: "chat.assistant_reply",
       sourceChannel: "vellum",
@@ -196,10 +243,10 @@ export async function emitAssistantReplyNotification(params: {
         // opting into v2.
         urgency: "medium",
         isAsyncBackground: false,
-        // The daemon cannot tell "still viewing" from "just left" at turn end.
-        // The viewing-on-iPhone case is covered by iOS suppressing remote
-        // pushes while the app is foregrounded.
-        visibleInSourceNow: false,
+        // Read weakly, as "at the machine this landed on": the attended Mac
+        // that opened the turn renders the reply in-app, and its Dock unread
+        // badge carries it while the window is hidden.
+        visibleInSourceNow: desktopAttended,
       },
       contextPayload: {
         ...(requestedTitle ? { requestedTitle } : {}),