@vellumai/assistant 0.8.2 → 0.8.4

package/src/notifications/broadcaster.ts

@@ -45,6 +45,11 @@ export interface ConversationCreatedInfo {
   groupId?: string;
   /** Semantic source from the signal producer (e.g. "schedule", "reminder"). */
   source?: string;
+  /**
+   * Mirrors the vellum adapter's `silent` flag. When true the client
+   * must skip the fallback OS banner — the sidebar entry still appears.
+   */
+  silent: boolean;
 }
 export type OnConversationCreatedFn = (info: ConversationCreatedInfo) => void;
 export interface BroadcastDecisionOptions {
@@ -145,10 +150,25 @@ export class NotificationBroadcaster {
         if (!fallbackCopy) {
           fallbackCopy = composeFallbackCopy(signal, decision.selectedChannels);
         }
-        copy = fallbackCopy[channel] ?? {
-          title: "Notification",
-          body: signal.sourceEventName,
-        };
+        copy = fallbackCopy[channel];
+      }
+
+      // Fail closed: if neither the decision nor the fallback composer produced
+      // a usable body, skip the channel rather than leaking the raw event name
+      // as placeholder text. The pre-send `checkRenderedCopyQuality` only sees
+      // `decision.renderedCopy`, so this is the last guard before delivery.
+      if (!copy || !copy.body?.trim()) {
+        log.warn(
+          { channel, signalId: signal.signalId },
+          "No usable rendered copy available -- skipping channel to avoid leaking event name",
+        );
+        results.push({
+          channel,
+          destination: destination.endpoint ?? channel,
+          status: "skipped",
+          errorMessage: `No usable rendered copy for channel: ${channel}`,
+        });
+        continue;
       }
 
       // For tool_grant_request signals, prefer the deterministic template seed
@@ -237,6 +257,9 @@ export class NotificationBroadcaster {
 
         const conversationTitle =
           copy.conversationTitle ?? copy.title ?? signal.sourceEventName;
+        const conversationSilent =
+          signal.attentionHints.urgency !== "high" &&
+          signal.attentionHints.urgency !== "critical";
         const info: ConversationCreatedInfo = {
           conversationId: pairing.conversationId,
           title: conversationTitle,
@@ -244,6 +267,7 @@ export class NotificationBroadcaster {
           targetGuardianPrincipalId,
           groupId: signal.conversationMetadata?.groupId,
           source: signal.conversationMetadata?.source,
+          silent: conversationSilent,
         };
 
         // The per-dispatch onConversationCreated callback fires whenever a vellum
@@ -291,6 +315,7 @@ export class NotificationBroadcaster {
         copy,
         deepLinkTarget,
         contextPayload: signal.contextPayload,
+        urgency: signal.attentionHints.urgency,
       };
 
       // Compute conversation decision audit fields for the delivery record

package/src/notifications/conversation-seed-composer.ts

@@ -156,8 +156,20 @@ export function composeConversationSeed(
 
   if (verbosity === "rich") {
     const parts: string[] = [];
-    if (copy.title && copy.title !== "Notification") parts.push(copy.title);
-    if (copy.body) parts.push(copy.body);
+    const usableTitle =
+      copy.title && copy.title !== "Notification" ? copy.title : "";
+    const hasBody = Boolean(copy.body && copy.body.trim());
+    // copy.title is used as the conversation header in chat surfaces
+    // whenever copy.conversationTitle is absent (see
+    // conversation-pairing.ts), so prepending it here would render it
+    // twice — once in the header bar and once at the start of the
+    // bubble. Skip it in that case, unless there's no body and we'd
+    // otherwise produce an empty seed. Treat whitespace-only bodies as
+    // empty so the title still populates the bubble.
+    if (usableTitle && (copy.conversationTitle || !hasBody)) {
+      parts.push(usableTitle);
+    }
+    if (hasBody) parts.push(copy.body);
     const alreadyMentionsAction = parts.some((part) =>
       /\baction required\b/i.test(part),
     );

package/src/notifications/copy-composer.ts

@@ -32,51 +32,6 @@ export function nonEmpty(value: string | undefined): string | undefined {
   return trimmed.length > 0 ? trimmed : undefined;
 }
 
-export function looksLikeIntermediaryInstruction(text: string): boolean {
-  const normalized = text.replace(/\s+/g, " ").trim();
-  const intermediaryAction =
-    "(?:tell|telling|ask|asking|remind|reminding|nudge|nudging|prompt|prompting|notify|notifying|encourage|encouraging|prime|priming|brief|briefing|coach|coaching)";
-  const target = "(?:the\\s+)?(?:guardian|recipient|user)";
-  return (
-    /\b(?:assistant|agent|system|model|watcher)\s+(?:should|needs?\s+to|must|can|could)\b/i.test(
-      normalized,
-    ) ||
-    new RegExp(
-      `\\b(?:consider|try|please)\\s+${intermediaryAction}\\s+${target}\\b`,
-      "i",
-    ).test(normalized) ||
-    new RegExp(
-      `\\b${intermediaryAction}\\s+${target}\\s+(?:to|that|about|with)\\b`,
-      "i",
-    ).test(normalized) ||
-    new RegExp(
-      `\\b${target}\\s+(?:should|needs?\\s+to|must|might\\s+want\\s+to)\\b`,
-      "i",
-    ).test(normalized) ||
-    new RegExp(`\\b(?:for|to)\\s+${target}\\s+to\\b`, "i").test(normalized)
-  );
-}
-
-function buildHeartbeatAlertCopy(
-  payload: Record<string, unknown>,
-): RenderedChannelCopy {
-  const summary = str(
-    payload.summary,
-    str(payload.body, "Your assistant found something worth your attention."),
-  ).trim();
-  const safePopupBody = looksLikeIntermediaryInstruction(summary)
-    ? "I found something worth your attention in a heartbeat check. Open the conversation for details."
-    : summary;
-
-  return {
-    title: str(payload.title, "Heartbeat Alert"),
-    body: safePopupBody,
-    deliveryText: safePopupBody,
-    conversationTitle: str(payload.conversationTitle, "Heartbeat"),
-    conversationSeedMessage: summary,
-  };
-}
-
 // ── Access-request copy contract ─────────────────────────────────────────────
 //
 // Deterministic helpers for building guardian-facing access-request copy.
@@ -550,8 +505,6 @@ const TEMPLATES: Partial<Record<NotificationSourceEventName, CopyTemplate>> = {
     body: str(payload.body, "A watcher event requires your attention"),
   }),
 
-  "heartbeat.alert": buildHeartbeatAlertCopy,
-
   "tool_confirmation.required_action": (payload) => ({
     title: "Tool Confirmation",
     body: str(payload.toolName, "A tool") + " requires your confirmation",
@@ -605,11 +558,11 @@ export function composeFallbackCopy(
 
   const baseCopy: RenderedChannelCopy = template
     ? template(signal.contextPayload)
-    : buildGenericCopy(signal);
+    : buildGenericCopy();
 
   const result: Partial<Record<NotificationChannel, RenderedChannelCopy>> = {};
   for (const ch of channels) {
-    result[ch] = applyChannelDefaults(ch, baseCopy, signal);
+    result[ch] = applyChannelDefaults(ch, baseCopy);
   }
   return result;
 }
@@ -617,12 +570,11 @@ export function composeFallbackCopy(
 function applyChannelDefaults(
   channel: NotificationChannel,
   baseCopy: RenderedChannelCopy,
-  signal: NotificationSignal,
 ): RenderedChannelCopy {
   const copy: RenderedChannelCopy = { ...baseCopy };
 
   if (channel === "telegram") {
-    copy.deliveryText = buildChatSurfaceFallbackDeliveryText(baseCopy, signal);
+    copy.deliveryText = buildChatSurfaceFallbackDeliveryText(baseCopy);
   }
 
   return copy;
@@ -630,7 +582,6 @@ function applyChannelDefaults(
 
 function buildChatSurfaceFallbackDeliveryText(
   baseCopy: RenderedChannelCopy,
-  signal: NotificationSignal,
 ): string {
   const explicit = nonEmpty(baseCopy.deliveryText);
   if (explicit) return explicit;
@@ -641,23 +592,25 @@ function buildChatSurfaceFallbackDeliveryText(
   const title = nonEmpty(baseCopy.title);
   if (title) return title;
 
-  return signal.sourceEventName.replace(/[._]/g, " ");
+  // No usable text: return empty string. The broadcaster's empty-body skip in
+  // `broadcaster.ts` suppresses fallback-derived empty bodies; the
+  // deterministic `checkRenderedCopyQuality` (see deterministic-checks.ts)
+  // covers the same case when the empty body originates in
+  // `decision.renderedCopy`.
+  return "";
 }
 
 /**
- * Build generic copy when no template matches. Uses the signal's
- * sourceEventName and attention hints to produce something reasonable.
+ * Build generic copy when no template matches. Returns an empty body so the
+ * notification is suppressed rather than rendering an event-name placeholder.
+ * The broadcaster's empty-body skip in `broadcaster.ts` catches fallback-derived
+ * empty bodies; the deterministic `checkRenderedCopyQuality` (see
+ * deterministic-checks.ts) covers the same case when the empty body originates
+ * in `decision.renderedCopy`.
  */
-function buildGenericCopy(signal: NotificationSignal): RenderedChannelCopy {
-  const humanName = signal.sourceEventName.replace(/[._]/g, " ");
-  const urgencyPrefix =
-    signal.attentionHints.urgency === "high" ? "Urgent: " : "";
-  const actionSuffix = signal.attentionHints.requiresAction
-    ? " — action required"
-    : "";
-
+function buildGenericCopy(): RenderedChannelCopy {
   return {
     title: "Notification",
-    body: `${urgencyPrefix}${humanName}${actionSuffix}`,
+    body: "",
   };
 }

package/src/notifications/decision-engine.ts

@@ -35,7 +35,6 @@ import {
   composeFallbackCopy,
   hasAccessRequestInstructions,
   hasInviteFlowDirective,
-  looksLikeIntermediaryInstruction,
 } from "./copy-composer.js";
 import { createDecision } from "./decisions-store.js";
 import {
@@ -58,6 +57,21 @@ const log = getLogger("notification-decision-engine");
 const DECISION_TIMEOUT_MS = 15_000;
 const PROMPT_VERSION = "v4";
 
+/**
+ * Derive a short notification title from a message body. Used when an
+ * assistant_tool-sourced signal supplies `requestedMessage` without an
+ * explicit `requestedTitle`: trims to the first sentence terminator when
+ * present, then caps the result at 60 characters with an ellipsis.
+ */
+function deriveTitle(body: string): string {
+  const firstSentenceEnd = body.search(/[.!?](\s|$)/);
+  const candidate =
+    firstSentenceEnd > 0 ? body.slice(0, firstSentenceEnd + 1) : body;
+  return candidate.length > 60
+    ? candidate.slice(0, 60).trim() + "…"
+    : candidate.trim();
+}
+
 /**
  * Maximum character budget for identity context injected into the notification
  * decision prompt. We truncate to prevent oversized prompts when SOUL.md /
@@ -668,47 +682,6 @@ function enforceAccessRequestInstructions(
   };
 }
 
-function enforceHeartbeatAlertCopy(
-  decision: NotificationDecision,
-  signal: NotificationSignal,
-): NotificationDecision {
-  if (signal.sourceEventName !== "heartbeat.alert") return decision;
-  if (!decision.shouldNotify || decision.selectedChannels.length === 0)
-    return decision;
-
-  const fallbackCopy = composeFallbackCopy(signal, decision.selectedChannels);
-  const nextCopy: Partial<Record<NotificationChannel, RenderedChannelCopy>> = {
-    ...decision.renderedCopy,
-  };
-
-  for (const channel of decision.selectedChannels) {
-    const currentCopy = nextCopy[channel];
-    if (
-      currentCopy &&
-      !heartbeatCopyLooksLikeIntermediaryInstruction(currentCopy)
-    ) {
-      continue;
-    }
-    const safeCopy = fallbackCopy[channel];
-    if (!safeCopy) continue;
-    nextCopy[channel] = safeCopy;
-  }
-
-  return {
-    ...decision,
-    renderedCopy: nextCopy,
-  };
-}
-
-function heartbeatCopyLooksLikeIntermediaryInstruction(
-  copy: RenderedChannelCopy,
-): boolean {
-  return [copy.title, copy.body, copy.deliveryText].some(
-    (value) =>
-      typeof value === "string" && looksLikeIntermediaryInstruction(value),
-  );
-}
-
 function ensureAccessRequestInstructionsInCopy(
   copy: RenderedChannelCopy,
   requestCode: string,
@@ -791,6 +764,102 @@ export async function evaluateSignal(
     );
   }
 
+  // Assistant-tool pass-through: when a producer hands us a verbatim
+  // message body via contextPayload.requestedMessage, skip the LLM
+  // classifier entirely. The producer has already done the routing and
+  // copy decisions — we just enforce the standard post-decision guards
+  // and persist the result.
+  if (
+    signal.sourceChannel === "assistant_tool" &&
+    typeof signal.contextPayload === "object" &&
+    signal.contextPayload != null &&
+    typeof (signal.contextPayload as Record<string, unknown>)
+      .requestedMessage === "string" &&
+    (
+      (signal.contextPayload as Record<string, unknown>)
+        .requestedMessage as string
+    ).trim().length > 0
+  ) {
+    const payload = signal.contextPayload as Record<string, unknown>;
+    const body = (payload.requestedMessage as string).trim();
+    const title =
+      typeof payload.requestedTitle === "string" &&
+      payload.requestedTitle.trim().length > 0
+        ? (payload.requestedTitle as string).trim()
+        : deriveTitle(body);
+    const isUrgent =
+      signal.attentionHints.urgency === "critical" ||
+      signal.attentionHints.urgency === "high";
+    const defaultChannels: NotificationChannel[] = isUrgent
+      ? [...availableChannels]
+      : availableChannels.includes("vellum")
+        ? ["vellum" as NotificationChannel]
+        : [];
+    // Honor `--preferred-channels` as ADDITIVE push targets on top of
+    // the default channel set. The notification center (vellum) is the
+    // always-on canonical inbox; preferred channels add push surfaces
+    // on top, they never replace vellum. Disconnected channels are
+    // filtered out so we never try to deliver on something unavailable.
+    const preferredChannelsRaw = Array.isArray(payload.preferredChannels)
+      ? (payload.preferredChannels as unknown[]).filter(
+          (c): c is string => typeof c === "string",
+        )
+      : undefined;
+    let selectedChannels = defaultChannels;
+    if (preferredChannelsRaw && preferredChannelsRaw.length > 0) {
+      const availableSet = new Set<string>(availableChannels);
+      const preferredAvailable = preferredChannelsRaw.filter((c) =>
+        availableSet.has(c),
+      ) as NotificationChannel[];
+      if (preferredAvailable.length > 0) {
+        selectedChannels = Array.from(
+          new Set<NotificationChannel>([
+            ...selectedChannels,
+            ...preferredAvailable,
+          ]),
+        );
+      }
+    }
+    // Thread `--deep-link-metadata` through when supplied as a plain object.
+    const deepLinkTarget =
+      payload.deepLinkMetadata != null &&
+      typeof payload.deepLinkMetadata === "object" &&
+      !Array.isArray(payload.deepLinkMetadata)
+        ? (payload.deepLinkMetadata as Record<string, unknown>)
+        : undefined;
+    // Populate renderedCopy and conversationActions for every available
+    // channel — not just `selectedChannels`. Downstream guards
+    // (routing-intent expansion in `enforceRoutingIntent`, urgency-forced
+    // vellum prepending in `emit-signal`) may widen `selectedChannels`
+    // beyond what we picked here. Pre-seeding copy for all channels ensures
+    // the verbatim message survives those expansions rather than falling
+    // back to an empty `composeFallbackCopy` body.
+    let decision: NotificationDecision = {
+      shouldNotify: selectedChannels.length > 0,
+      selectedChannels,
+      reasoningSummary: "assistant_tool pass-through",
+      renderedCopy: Object.fromEntries(
+        availableChannels.map((ch) => [ch, { title, body }]),
+      ) as NotificationDecision["renderedCopy"],
+      conversationActions: Object.fromEntries(
+        availableChannels.map((ch) => [ch, { action: "start_new" as const }]),
+      ) as NotificationDecision["conversationActions"],
+      dedupeKey: signal.signalId,
+      confidence: 1.0,
+      fallbackUsed: false,
+      ...(deepLinkTarget ? { deepLinkTarget } : {}),
+    };
+    decision = enforceGuardianRequestCode(decision, signal);
+    decision = enforceAccessRequestInstructions(decision, signal);
+    decision = enforceGuardianCallConversationAffinity(decision, signal);
+    decision = enforceConversationAffinity(
+      decision,
+      signal.conversationAffinityHint,
+    );
+    decision.persistedDecisionId = persistDecision(signal, decision);
+    return decision;
+  }
+
   const provider = await getConfiguredProvider("notificationDecision");
   if (!provider) {
     log.warn(
@@ -799,7 +868,6 @@ export async function evaluateSignal(
     let decision = buildFallbackDecision(signal, availableChannels);
     decision = enforceGuardianRequestCode(decision, signal);
     decision = enforceAccessRequestInstructions(decision, signal);
-    decision = enforceHeartbeatAlertCopy(decision, signal);
     decision = enforceGuardianCallConversationAffinity(decision, signal);
     decision = enforceConversationAffinity(
       decision,
@@ -829,7 +897,6 @@ export async function evaluateSignal(
 
   decision = enforceGuardianRequestCode(decision, signal);
   decision = enforceAccessRequestInstructions(decision, signal);
-  decision = enforceHeartbeatAlertCopy(decision, signal);
   decision = enforceGuardianCallConversationAffinity(decision, signal);
   decision = enforceConversationAffinity(
     decision,

package/src/notifications/deferred-emit.ts

@@ -0,0 +1,135 @@
+/**
+ * Per-conversation notification buffer used to keep a background job's
+ * "success" notification from racing the runner's `activity.failed` when
+ * the job times out after the model already invoked `notifications send`.
+ *
+ * `registerDeferredConversation` arms the buffer before the LLM turn.
+ * `bufferIfDeferred` is called from the IPC route handler — it buffers when
+ * armed, swallows when tombstoned (post-discard grace window), and returns
+ * null otherwise so the route emits normally.
+ * `commitDeferredConversation` flushes on success; `discardDeferredConversation`
+ * drops on failure and tombstones briefly to catch late tool calls that
+ * arrive after `processMessage` keeps running past the runner's timeout.
+ */
+
+import { v4 as uuid } from "uuid";
+
+import { getLogger } from "../util/logger.js";
+import {
+  emitNotificationSignal,
+  type EmitSignalParams,
+  type EmitSignalResult,
+} from "./emit-signal.js";
+
+const log = getLogger("notifications-deferred-emit");
+
+// How long after the last observed late notification we keep the tombstone
+// alive. `work` in `runBackgroundJob` is not cancelled on timeout — it can
+// continue running and emit skill calls indefinitely. We refresh the timer
+// on every late arrival, so the tombstone persists as long as the turn is
+// still draining and only expires once the conversation has been quiet for
+// this long.
+const TOMBSTONE_TTL_MS = 5 * 60 * 1000;
+
+type BufferEntry =
+  | { state: "buffered"; items: EmitSignalParams<string>[] }
+  | { state: "tombstoned"; timer: ReturnType<typeof setTimeout> };
+
+const buffers = new Map<string, BufferEntry>();
+
+function scheduleTombstoneEviction(
+  conversationId: string,
+): ReturnType<typeof setTimeout> {
+  const timer = setTimeout(() => {
+    const cur = buffers.get(conversationId);
+    if (cur?.state === "tombstoned") buffers.delete(conversationId);
+  }, TOMBSTONE_TTL_MS);
+  timer.unref?.();
+  return timer;
+}
+
+export function registerDeferredConversation(conversationId: string): void {
+  buffers.set(conversationId, { state: "buffered", items: [] });
+}
+
+/**
+ * Buffer the signal when the originating conversation is armed, swallow it
+ * when tombstoned, otherwise return null so the caller emits normally.
+ */
+export function bufferIfDeferred(
+  originatingConversationId: string | undefined,
+  params: EmitSignalParams<string>,
+): EmitSignalResult | null {
+  if (!originatingConversationId) return null;
+  const entry = buffers.get(originatingConversationId);
+  if (!entry) return null;
+  if (entry.state === "tombstoned") {
+    // Refresh the eviction timer so the tombstone outlives any continuing
+    // turn activity. Otherwise a long-running orphan `processMessage` could
+    // emit a `notifications send` after the fixed TTL elapsed and bypass
+    // buffering, recreating the "success + activity.failed" contradiction.
+    clearTimeout(entry.timer);
+    entry.timer = scheduleTombstoneEviction(originatingConversationId);
+    return {
+      signalId: uuid(),
+      deduplicated: false,
+      dispatched: false,
+      reason: "Notification dropped: background job did not complete",
+      deliveryResults: [],
+    };
+  }
+  entry.items.push(params);
+  return {
+    signalId: uuid(),
+    deduplicated: false,
+    dispatched: false,
+    reason: "Notification deferred until background job completes",
+    deliveryResults: [],
+  };
+}
+
+export async function commitDeferredConversation(
+  conversationId: string,
+): Promise<void> {
+  const entry = buffers.get(conversationId);
+  if (!entry || entry.state !== "buffered") return;
+  buffers.delete(conversationId);
+  for (const params of entry.items) {
+    try {
+      await emitNotificationSignal(params);
+    } catch (err) {
+      log.warn(
+        { err, conversationId },
+        "Buffered notification failed to emit on commit",
+      );
+    }
+  }
+}
+
+/**
+ * Drop any buffered signals and tombstone the conversation. The tombstone
+ * persists until the turn has been quiet for `TOMBSTONE_TTL_MS`; each late
+ * notification observed via `bufferIfDeferred` refreshes the timer.
+ */
+export function discardDeferredConversation(conversationId: string): number {
+  const entry = buffers.get(conversationId);
+  if (!entry) return 0;
+  const droppedCount = entry.state === "buffered" ? entry.items.length : 0;
+  if (entry.state === "tombstoned") clearTimeout(entry.timer);
+  buffers.set(conversationId, {
+    state: "tombstoned",
+    timer: scheduleTombstoneEviction(conversationId),
+  });
+  if (droppedCount > 0) {
+    log.info(
+      { conversationId, droppedCount },
+      "Discarded buffered notifications for failed background job",
+    );
+  }
+  return droppedCount;
+}
+
+/** @internal Test-only reset hook. */
+export function resetDeferredForTest(): void {
+  buffers.clear();
+}

package/src/notifications/deterministic-checks.ts

@@ -12,6 +12,7 @@ import { and, eq } from "drizzle-orm";
 import { getDb } from "../memory/db-connection.js";
 import { notificationEvents } from "../memory/schema.js";
 import { getLogger } from "../util/logger.js";
+import { composeFallbackCopy } from "./copy-composer.js";
 import type { NotificationSignal } from "./signal.js";
 import type { NotificationChannel, NotificationDecision } from "./types.js";
 
@@ -88,6 +89,16 @@ export async function runDeterministicChecks(
     return dedupeCheck;
   }
 
+  // Check 5: Rendered copy quality (fail-closed)
+  const copyCheck = checkRenderedCopyQuality(signal, decision);
+  if (!copyCheck.passed) {
+    log.info(
+      { signalId: signal.signalId, reason: copyCheck.reason },
+      "Deterministic check failed: rendered copy quality",
+    );
+    return copyCheck;
+  }
+
   return { passed: true };
 }
 
@@ -232,3 +243,88 @@ function checkDedupe(
 
   return { passed: true };
 }
+
+/**
+ * Fail-closed check that the rendered copy is real text and not an
+ * accidental fallback leak (empty body, or body that is just the raw
+ * source event name like "user.send_notification").
+ *
+ * Only validates channels that the decision engine actually emitted
+ * copy for. Channels appended after the decision (urgency-forced
+ * `vellum` prepend, `enforceRoutingIntent` expansion) have no entry
+ * in `renderedCopy` and are left for the broadcaster's
+ * `composeFallbackCopy` rescue at delivery time.
+ *
+ * If `renderedCopy` is empty for every selected channel, the
+ * broadcaster's fallback must produce a usable body — otherwise the
+ * signal would be silently dropped at delivery (broadcaster skips
+ * empty-body channels, `dispatchDecision` reports 0/N sent). In that
+ * case, require `composeFallbackCopy` to yield a non-empty body for
+ * at least one selected channel; otherwise fail-closed.
+ *
+ * The event-name-match branch is skipped for `assistant_tool`
+ * pass-through decisions because the producer supplied the body
+ * verbatim — a coincidental match with the event name is the user's
+ * intent, not a fallback leak.
+ */
+function checkRenderedCopyQuality(
+  signal: NotificationSignal,
+  decision: NotificationDecision,
+): CheckResult {
+  if (!decision.shouldNotify) {
+    return { passed: true };
+  }
+
+  const isAssistantToolPassthrough =
+    decision.reasoningSummary === "assistant_tool pass-through";
+  const normalizedEventName = signal.sourceEventName
+    .replace(/[._]/g, " ")
+    .toLowerCase()
+    .trim();
+  const rawEventName = signal.sourceEventName.toLowerCase();
+
+  let anyChannelHasCopy = false;
+  for (const channel of decision.selectedChannels) {
+    const copy = decision.renderedCopy[channel];
+    if (!copy) {
+      continue;
+    }
+    anyChannelHasCopy = true;
+    const trimmedBody = copy.body.trim();
+    if (trimmedBody.length === 0) {
+      return {
+        passed: false,
+        reason: "rendered copy body is empty",
+      };
+    }
+    if (isAssistantToolPassthrough) {
+      continue;
+    }
+    const normalizedBody = trimmedBody.toLowerCase();
+    if (
+      normalizedBody === normalizedEventName ||
+      normalizedBody === rawEventName
+    ) {
+      return {
+        passed: false,
+        reason: "rendered copy body is the source event name (fallback leak)",
+      };
+    }
+  }
+
+  if (!anyChannelHasCopy && decision.selectedChannels.length > 0) {
+    const fallback = composeFallbackCopy(signal, decision.selectedChannels);
+    const fallbackUsable = decision.selectedChannels.some(
+      (ch) => (fallback[ch]?.body ?? "").trim().length > 0,
+    );
+    if (!fallbackUsable) {
+      return {
+        passed: false,
+        reason:
+          "rendered copy missing for all selected channels and fallback body is empty (would silently drop)",
+      };
+    }
+  }
+
+  return { passed: true };
+}