@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/notifications/copy-composer.ts

@@ -9,6 +9,7 @@
  * values from the context payload.
  */
 
+import { normalizeTitle } from "../util/short-title.js";
 import {
   accessRequestCardTitle,
   buildAccessRequestContractText,
@@ -26,6 +27,7 @@ import {
 } from "./guardian-question-mode.js";
 import {
   nonEmpty,
+  NOTIFICATION_TITLE_MAX_LENGTH,
   readPayloadString,
   sanitizeIdentityField,
 } from "./notification-utils.js";
@@ -48,17 +50,35 @@ function str(value: unknown, fallback: string): string {
 /**
  * Derive a short notification title from a message body. Trims to the
  * first sentence terminator when present, then caps the result at
- * 60 characters with an ellipsis.
+ * `NOTIFICATION_TITLE_MAX_LENGTH` characters with an ellipsis.
  */
 export 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() + "\u2026"
+  return candidate.length > NOTIFICATION_TITLE_MAX_LENGTH
+    ? candidate.slice(0, NOTIFICATION_TITLE_MAX_LENGTH).trim() + "\u2026"
     : candidate.trim();
 }
 
+/**
+ * Clean a producer-authored title, falling back to one derived from the body
+ * when `normalizeTitle` returns its empty-string rejection signal.
+ *
+ * The decision engine's pass-through path applies the same clamp, so a signal
+ * carrying `requestedTitle` renders the same headline whether or not the LLM
+ * classifier was reachable.
+ *
+ * The two branches carry different budgets. An accepted authored title is
+ * bounded by `normalizeTitle` at 40 characters. A rejected one falls through to
+ * `deriveTitle`, which never sees the normalizer and applies
+ * `NOTIFICATION_TITLE_MAX_LENGTH` (60) plus a trailing ellipsis, so a derived
+ * title can reach 61 characters.
+ */
+export function resolveTitle(raw: string | undefined, body: string): string {
+  return normalizeTitle(raw ?? "") || deriveTitle(body);
+}
+
 /**
  * Build a display label for a trusted-contact actor (requester or decider),
  * preferring the display name, then a Slack `<@id>` mention for raw Slack user
@@ -290,9 +310,10 @@ export function composeFallbackCopy(
     readPayloadString(signal.contextPayload, "requestedMessage"),
   );
   if (msg) {
-    const title =
-      nonEmpty(readPayloadString(signal.contextPayload, "requestedTitle")) ??
-      deriveTitle(msg);
+    const title = resolveTitle(
+      readPayloadString(signal.contextPayload, "requestedTitle"),
+      msg,
+    );
     const baseCopy: RenderedChannelCopy = {
       title,
       body: msg,

package/src/notifications/decision-engine.ts

@@ -44,7 +44,7 @@ import {
   type ConversationCandidateSet,
   serializeCandidatesForPrompt,
 } from "./conversation-candidates.js";
-import { composeFallbackCopy, deriveTitle } from "./copy-composer.js";
+import { composeFallbackCopy, resolveTitle } from "./copy-composer.js";
 import { createDecision } from "./decisions-store.js";
 import {
   buildGuardianRequestCodeInstruction,
@@ -54,7 +54,11 @@ import {
   stripConflictingGuardianRequestInstructions,
   stripGuardianRequestCodeInstructions,
 } from "./guardian-question-mode.js";
-import { nonEmpty, readPayloadString } from "./notification-utils.js";
+import {
+  nonEmpty,
+  readPayloadObject,
+  readPayloadString,
+} from "./notification-utils.js";
 import { getPreferenceSummary } from "./preference-summary.js";
 import type { NotificationSignal, RoutingIntent } from "./signal.js";
 import type {
@@ -78,6 +82,16 @@ const PROMPT_VERSION = "v4";
  */
 const MAX_IDENTITY_CONTEXT_CHARS = 2000;
 
+/**
+ * Delivery scope for `chat.assistant_reply` signals: the platform channel is a
+ * push_only relay that never materializes a conversation, so these signals
+ * reach the user exclusively as a push. Adding a channel here widens delivery
+ * to it.
+ */
+const ASSISTANT_REPLY_CHANNELS = [
+  "platform",
+] as const satisfies readonly NotificationChannel[];
+
 // ── System prompt ──────────────────────────────────────────────────────
 
 function buildSystemPrompt(
@@ -215,6 +229,26 @@ function buildUserPrompt(signal: NotificationSignal): string {
 
 // ── Tool definition ────────────────────────────────────────────────────
 
+/**
+ * Spec for the per-channel notification title. Mirrors the conversation title
+ * prompt (`persistence/conversation-title-service.ts`), which gets clean
+ * noun-phrase headlines out of this same model profile.
+ */
+const TITLE_FIELD_DESCRIPTION = [
+  "Scannable headline naming the TOPIC of this notification, not a summary of it.",
+  "Rules:",
+  "- 2 to 5 words. Longer titles are unacceptable, ruthlessly compress",
+  "- 40 characters absolute maximum, longer titles get truncated and look broken",
+  "- A noun phrase naming the topic, never a sentence, question, or greeting (e.g. 'Platform Standup', 'Nightly Backup Failure')",
+  "- Do NOT restate, summarize, or echo the body. The title and the body must carry different information",
+  "- No quotes, no markdown, no trailing punctuation",
+  "- Never describe missing or thin context. Titles like 'Notification', 'Update', 'Missing Context' are forbidden. Extract a topic from the words that ARE present",
+  "Examples:",
+  "- Body 'Your 9am standup with the platform team starts in 5 minutes' -> 'Platform Standup', NOT 'Standup Starts In 5 Minutes'",
+  "- Body 'The nightly backup job failed on db-primary at 02:14' -> 'Nightly Backup Failure', NOT 'Nightly Backup Job Failed On db-primary'",
+  "- Body 'Alice replied about the Q3 pricing deck and wants your notes' -> 'Q3 Pricing Deck', NOT 'Alice Replied About The Pricing Deck'",
+].join("\n");
+
 function buildDecisionTool(availableChannels: NotificationChannel[]) {
   return {
     name: "record_notification_decision",
@@ -250,7 +284,7 @@ function buildDecisionTool(availableChannels: NotificationChannel[]) {
                 properties: {
                   title: {
                     type: "string",
-                    description: "Short notification popup title (≤ 8 words)",
+                    description: TITLE_FIELD_DESCRIPTION,
                   },
                   body: {
                     type: "string",
@@ -431,7 +465,7 @@ function validateDecisionOutput(
             );
           }
           renderedCopy[ch] = {
-            title: c.title,
+            title: resolveTitle(c.title, c.body),
             body: c.body,
             deliveryText:
               typeof c.deliveryText === "string" ? c.deliveryText : undefined,
@@ -855,6 +889,70 @@ function ensureInviteFlowDirectiveInCopy(
   };
 }
 
+// ── Producer pass-through decisions ────────────────────────────────────
+
+/**
+ * Build, guard, and persist a decision whose copy came verbatim from the
+ * producer, bypassing the LLM classifier. The title falls back to one derived
+ * from the body when the producer supplies none or supplies one that fails
+ * normalization.
+ *
+ * `renderedCopy` and `conversationActions` are populated for every available
+ * channel, not just `selectedChannels`: downstream guards (routing-intent
+ * expansion in `enforceRoutingIntent`, urgency-forced vellum prepending in
+ * `emit-signal`) may widen `selectedChannels` afterwards, and pre-seeding
+ * keeps the verbatim message from degrading to an empty
+ * `composeFallbackCopy` body.
+ */
+function buildPassThroughDecision(params: {
+  signal: NotificationSignal;
+  availableChannels: NotificationChannel[];
+  selectedChannels: NotificationChannel[];
+  body: string;
+  reasoningSummary: string;
+}): NotificationDecision {
+  const { availableChannels, body, signal } = params;
+  const title = resolveTitle(
+    readPayloadString(signal.contextPayload, "requestedTitle"),
+    body,
+  );
+  const deepLinkTarget = readPayloadObject(
+    signal.contextPayload,
+    "deepLinkMetadata",
+  );
+  let decision: NotificationDecision = {
+    shouldNotify: params.selectedChannels.length > 0,
+    selectedChannels: params.selectedChannels,
+    reasoningSummary: params.reasoningSummary,
+    renderedCopy: Object.fromEntries(
+      availableChannels.map((ch) => [
+        ch,
+        { title, body, conversationSeedMessage: body },
+      ]),
+    ) as NotificationDecision["renderedCopy"],
+    conversationActions: Object.fromEntries(
+      availableChannels.map((ch) => [ch, { action: "start_new" as const }]),
+    ) as NotificationDecision["conversationActions"],
+    // A producer-supplied key names what it wants collapsed; the signal id is
+    // a per-emit fallback that collapses nothing.
+    dedupeKey: signal.dedupeKey ?? signal.signalId,
+    confidence: 1.0,
+    fallbackUsed: false,
+    verbatimCopy: true,
+    ...(deepLinkTarget ? { deepLinkTarget } : {}),
+  };
+  decision = enforceGuardianRequestCode(decision, signal);
+  decision = enforceToolApprovalSeedBlocks(decision, signal);
+  decision = enforceAccessRequestInstructions(decision, signal);
+  decision = enforceGuardianRequestConversationAffinity(decision, signal);
+  decision = enforceConversationAffinity(
+    decision,
+    signal.conversationAffinityHint,
+  );
+  decision.persistedDecisionId = persistDecision(signal, decision);
+  return decision;
+}
+
 // ── Core evaluation function ───────────────────────────────────────────
 
 export async function evaluateSignal(
@@ -862,50 +960,20 @@ export async function evaluateSignal(
   availableChannels: NotificationChannel[],
   preferenceContext?: string,
 ): Promise<NotificationDecision> {
-  // When no explicit preference context is provided, load the user's
-  // stored notification preferences from the memory-backed store.
-  // Wrapped in try/catch so a DB failure doesn't break the decision path.
-  let resolvedPreferenceContext = preferenceContext;
-  if (resolvedPreferenceContext === undefined) {
-    try {
-      resolvedPreferenceContext = getPreferenceSummary() ?? undefined;
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      log.warn(
-        { err: errMsg },
-        "Failed to load preference summary, proceeding without preferences",
-      );
-      resolvedPreferenceContext = undefined;
-    }
-  }
-
-  // Build conversation candidate set for reuse decisions. Wrapped in try/catch
-  // so candidate lookup failures do not block the decision path.
-  let candidateSet: ConversationCandidateSet | undefined;
-  try {
-    candidateSet = await buildConversationCandidates(availableChannels);
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    log.warn(
-      { err: errMsg },
-      "Failed to build conversation candidates, proceeding without candidates",
-    );
-  }
+  // Pass-through branches run before the preference and candidate loads
+  // below: their copy and routing are producer-supplied, so neither DB
+  // lookup can influence the outcome.
 
   // 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
+  // copy decisions, we just enforce the standard post-decision guards
   // and persist the result.
   const requestedBody = nonEmpty(
     readPayloadString(signal.contextPayload, "requestedMessage"),
   );
   if (signal.sourceChannel === "assistant_tool" && requestedBody) {
     const payload = signal.contextPayload as Record<string, unknown>;
-    const body = requestedBody;
-    const title =
-      nonEmpty(readPayloadString(signal.contextPayload, "requestedTitle")) ??
-      deriveTitle(body);
     const isUrgent =
       signal.attentionHints.urgency === "critical" ||
       signal.attentionHints.urgency === "high";
@@ -939,48 +1007,57 @@ export async function evaluateSignal(
         );
       }
     }
-    // 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,
+    return buildPassThroughDecision({
+      signal,
+      availableChannels,
       selectedChannels,
+      body: requestedBody,
       reasoningSummary: "assistant_tool pass-through",
-      renderedCopy: Object.fromEntries(
-        availableChannels.map((ch) => [
-          ch,
-          { title, body, conversationSeedMessage: 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 = enforceToolApprovalSeedBlocks(decision, signal);
-    decision = enforceAccessRequestInstructions(decision, signal);
-    decision = enforceGuardianRequestConversationAffinity(decision, signal);
-    decision = enforceConversationAffinity(
-      decision,
-      signal.conversationAffinityHint,
+    });
+  }
+
+  // Assistant-reply pass-through: the delivery scope is fixed
+  // (ASSISTANT_REPLY_CHANNELS), so the LLM classifier has nothing to decide.
+  if (signal.sourceEventName === "chat.assistant_reply" && requestedBody) {
+    return buildPassThroughDecision({
+      signal,
+      availableChannels,
+      selectedChannels: ASSISTANT_REPLY_CHANNELS.filter((ch) =>
+        availableChannels.includes(ch),
+      ),
+      body: requestedBody,
+      reasoningSummary: "assistant_reply pass-through",
+    });
+  }
+
+  // When no explicit preference context is provided, load the user's
+  // stored notification preferences from the memory-backed store.
+  // Wrapped in try/catch so a DB failure doesn't break the decision path.
+  let resolvedPreferenceContext = preferenceContext;
+  if (resolvedPreferenceContext === undefined) {
+    try {
+      resolvedPreferenceContext = getPreferenceSummary() ?? undefined;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log.warn(
+        { err: errMsg },
+        "Failed to load preference summary, proceeding without preferences",
+      );
+      resolvedPreferenceContext = undefined;
+    }
+  }
+
+  // Build conversation candidate set for reuse decisions. Wrapped in try/catch
+  // so candidate lookup failures do not block the decision path.
+  let candidateSet: ConversationCandidateSet | undefined;
+  try {
+    candidateSet = await buildConversationCandidates(availableChannels);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    log.warn(
+      { err: errMsg },
+      "Failed to build conversation candidates, proceeding without candidates",
     );
-    decision.persistedDecisionId = persistDecision(signal, decision);
-    return decision;
   }
 
   const provider = await getConfiguredProvider("notificationDecision");

package/src/notifications/deterministic-checks.ts

@@ -269,10 +269,10 @@ function checkDedupe(
  * 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.
+ * The event-name-match branch is skipped for decisions flagged
+ * `verbatimCopy` because the producer supplied the body verbatim, so a
+ * coincidental match with the event name is the producer's intent, not a
+ * fallback leak.
  */
 function checkRenderedCopyQuality(
   signal: NotificationSignal,
@@ -282,8 +282,7 @@ function checkRenderedCopyQuality(
     return { passed: true };
   }
 
-  const isAssistantToolPassthrough =
-    decision.reasoningSummary === "assistant_tool pass-through";
+  const isPassthrough = decision.verbatimCopy === true;
   const normalizedEventName = signal.sourceEventName
     .replace(/[._]/g, " ")
     .toLowerCase()
@@ -304,7 +303,7 @@ function checkRenderedCopyQuality(
         reason: "rendered copy body is empty",
       };
     }
-    if (isAssistantToolPassthrough) {
+    if (isPassthrough) {
       continue;
     }
     const normalizedBody = trimmedBody.toLowerCase();

package/src/notifications/edit-notification.ts

@@ -22,6 +22,7 @@ import {
   updateDeliveryRenderedCopy,
 } from "./deliveries-store.js";
 import { getBroadcaster } from "./emit-signal.js";
+import { nonEmpty } from "./notification-utils.js";
 import type { NotificationChannel } from "./types.js";
 
 const log = getLogger("edit-notification");
@@ -88,8 +89,12 @@ export async function editNotification(
 ): Promise<EditNotificationResult | null> {
   const feedItemId = normalizeFeedItemId(params.id);
 
+  // Titles are never cleared, so a blank one is dropped before it can
+  // reach the feed patch or a channel update.
+  const title = nonEmpty(params.title);
+
   const feedItem = await patchFeedItemContent(feedItemId, {
-    title: params.title,
+    title,
     summary: params.body,
     urgency: params.urgency,
     status: params.status,
@@ -102,8 +107,7 @@ export async function editNotification(
   // Only edit channel messages when the user-visible text changed.
   // Urgency/status are feed-only — pushing a channel update for those
   // alone would re-deliver the same body and confuse the recipient.
-  const shouldUpdateChannels =
-    params.title !== undefined || params.body !== undefined;
+  const shouldUpdateChannels = title !== undefined || params.body !== undefined;
   if (!shouldUpdateChannels) {
     return { feedItem, channels: [] };
   }
@@ -120,7 +124,7 @@ export async function editNotification(
 
   const deliveries = findDeliveriesByDecisionId(decision.id);
   const channels = await updateChannelDeliveries(deliveries, {
-    title: params.title,
+    title,
     body: params.body,
   });
 

package/src/notifications/emit-signal.ts

@@ -18,6 +18,7 @@ import {
   guardianForChannel,
 } from "../contacts/guardian-delivery-reader.js";
 import type { ConversationCreateType } from "../persistence/conversation-types.js";
+import { isPlatformClientConfigured } from "../platform/client.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
 import { VellumAdapter } from "./adapters/macos.js";
@@ -253,6 +254,7 @@ export async function emitNotificationSignal<TEventName extends string>(
     contextPayload: (params.contextPayload ??
       {}) as NotificationContextPayload<TEventName>,
     attentionHints: params.attentionHints,
+    dedupeKey: params.dedupeKey,
     routingIntent: params.routingIntent,
     routingHints: params.routingHints,
     conversationAffinityHint: params.conversationAffinityHint,
@@ -320,25 +322,55 @@ export async function emitNotificationSignal<TEventName extends string>(
 
     let decision = await evaluateSignal(signal, connectedChannels);
 
-    // Step 2.5a: High/critical urgency signals always get a system
-    // notification via the vellum channel, regardless of what the
-    // decision engine selected. This ensures macOS surfaces a banner
-    // even when the app is focused.
+    // Baseline for the re-persist check below. Captured before the policy
+    // steps (2.5a/2.5b/2.5c) so any of them replacing the decision triggers
+    // the re-persist and the stored row matches what is dispatched.
+    const prePolicyDecision = decision;
+
+    // Step 2.5a: High/critical urgency signals always get both the in-app
+    // system notification (vellum) and the remote push (platform),
+    // regardless of what the decision engine selected. macOS surfaces a
+    // banner even when the app is focused, and a suspended iOS device is
+    // only reachable via APNs. Platform is only forced when the daemon has
+    // platform credentials and an assistant id -- on unbound daemons the
+    // dispatch can never succeed and would write a failed delivery row per
+    // signal. The probe is deadline-bounded internally, so a slow credential
+    // backend cannot stall the urgent dispatch.
+    //
+    // Vellum PREPENDS and platform APPENDS: the broadcaster re-sorts by
+    // dispatch rank, so selection order only matters to single_channel
+    // enforcement's first-selected fallback (step 2.5b), which must keep
+    // the in-app banner rather than a push the server may skip.
     const urgency = signal.attentionHints.urgency;
     if (
       (urgency === "high" || urgency === "critical") &&
-      decision.shouldNotify &&
-      !decision.selectedChannels.includes("vellum")
+      decision.shouldNotify
     ) {
-      decision = {
-        ...decision,
-        selectedChannels: ["vellum", ...decision.selectedChannels],
-        reasoningSummary: `${decision.reasoningSummary} (vellum forced: ${urgency} urgency)`,
-      };
+      const selectedChannels: NotificationChannel[] = [
+        ...decision.selectedChannels,
+      ];
+      const forcedChannels: NotificationChannel[] = [];
+      if (!selectedChannels.includes("vellum")) {
+        selectedChannels.unshift("vellum");
+        forcedChannels.push("vellum");
+      }
+      if (
+        !selectedChannels.includes("platform") &&
+        (await isPlatformClientConfigured())
+      ) {
+        selectedChannels.push("platform");
+        forcedChannels.push("platform");
+      }
+      if (forcedChannels.length > 0) {
+        decision = {
+          ...decision,
+          selectedChannels,
+          reasoningSummary: `${decision.reasoningSummary} (${forcedChannels.join(", ")} forced: ${urgency} urgency)`,
+        };
+      }
     }
 
     // Step 2.5b: Enforce routing intent policy (fire-time guard)
-    const preEnforcementDecision = decision;
     decision = enforceRoutingIntent(
       decision,
       signal.routingIntent,
@@ -368,9 +400,10 @@ export async function emitNotificationSignal<TEventName extends string>(
       };
     }
 
-    // Re-persist the decision if routing intent enforcement changed it,
-    // so the stored decision row matches what is actually dispatched.
-    if (decision !== preEnforcementDecision && decision.persistedDecisionId) {
+    // Re-persist the decision if any policy step changed it (urgency channel
+    // forcing, routing intent enforcement, or the access-request vellum
+    // floor), so the stored decision row matches what is actually dispatched.
+    if (decision !== prePolicyDecision && decision.persistedDecisionId) {
       try {
         updateDecision(decision.persistedDecisionId, {
           selectedChannels: decision.selectedChannels,
@@ -384,7 +417,7 @@ export async function emitNotificationSignal<TEventName extends string>(
       } catch (err) {
         log.warn(
           { err, signalId },
-          "Failed to re-persist decision after routing intent enforcement",
+          "Failed to re-persist decision after policy enforcement",
         );
       }
     }

package/src/notifications/guardian-delivery-recorder.ts

@@ -91,8 +91,10 @@ export async function recordApprovalCardDelivery(
  * that row's id as `vellumDeliveryId` and it is reused (only its status applied)
  * — otherwise the vellum row is created here from the result.
  *
- * Every result records the internal `conversationId` the card is shown in, so a
- * conversation's pending cards can be found uniformly regardless of channel.
+ * Every addressable result records the internal `conversationId` the card is
+ * shown in, so a conversation's pending cards can be found uniformly
+ * regardless of channel. Platform push results are skipped entirely: a push
+ * has no channel-native card surface to address back to.
  * Channel results additionally carry the chat (`destination`) and channel-native
  * id (`messageId`) used to match inbound replies/reactions; a blank `destination`
  * is recorded as unknown rather than persisting the literal channel name as a
@@ -112,6 +114,10 @@ export async function recordGuardianRequestDeliveries(params: {
   let vellumDeliveryId = params.vellumDeliveryId;
 
   for (const result of deliveryResults) {
+    if (result.channel === "platform") {
+      // A push is not an independently addressable card surface -- no row.
+      continue;
+    }
     let deliveryId: string | undefined;
     if (result.channel === "vellum") {
       if (!vellumDeliveryId) {

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

@@ -20,7 +20,9 @@ import { appendFeedItem } from "../home/feed-writer.js";
 import { getConversation } from "../persistence/conversation-crud.js";
 import { isBackgroundConversationType } from "../persistence/conversation-types.js";
 import { getLogger } from "../util/logger.js";
+import { normalizeTitle, stripMarkdown } from "../util/short-title.js";
 import { isConversationSeedSane } from "./conversation-seed-composer.js";
+import { deriveTitle } from "./copy-composer.js";
 import { readPayloadString } from "./notification-utils.js";
 import type { NotificationSignal } from "./signal.js";
 import type { NotificationDecision, RenderedChannelCopy } from "./types.js";
@@ -66,11 +68,6 @@ export async function writeHomeFeedItemForSignal(
     readPayloadString(signal.contextPayload, "body") ??
     readPayloadString(signal.contextPayload, "requestedMessage");
 
-  // Source the title from the payload only. The LLM's `renderedCopy.title`
-  // often echoes the body when no explicit title was passed, which stutters
-  // against `summary` in the row. Leave undefined when absent; renderers
-  // fall back to `summary`.
-  const resolvedTitle = payloadTitle?.trim() || undefined;
   // Prefer conversationSeedMessage over body for the home feed: the seed
   // message is richer and may contain structured markdown (lists, headers,
   // bold) that the detail panel renders. The popup-oriented `body` is
@@ -91,6 +88,15 @@ export async function writeHomeFeedItemForSignal(
     return null;
   }
 
+  // Title order: payload, then the rendered copy, then a headline derived
+  // from the summary. `normalizeTitle` returns "" for empty, prose-shaped, and
+  // meta-failure candidates; the derivation always yields something, so every
+  // feed item lands with a title.
+  const resolvedTitle =
+    normalizeTitle(payloadTitle ?? "") ||
+    normalizeTitle(renderedCopy?.title ?? "") ||
+    deriveFallbackTitle(resolvedSummary);
+
   const urgency = signal.attentionHints.urgency;
   const now = new Date().toISOString();
 
@@ -122,7 +128,7 @@ export async function writeHomeFeedItemForSignal(
     id: `notif:${signal.signalId}`,
     type: "notification",
     priority: 50,
-    ...(resolvedTitle ? { title: resolvedTitle } : {}),
+    title: resolvedTitle,
     summary: resolvedSummary,
     timestamp: now,
     createdAt: now,
@@ -150,6 +156,37 @@ export async function writeHomeFeedItemForSignal(
   return item;
 }
 
+/**
+ * Derive the terminal fallback headline from the summary.
+ *
+ * The summary is preferentially a conversation seed, which carries structured
+ * markdown and hard line breaks, so flatten it to plain single-line text
+ * before slicing a headline off the front. A non-empty summary always yields a
+ * non-empty title.
+ */
+function deriveFallbackTitle(summary: string): string {
+  // Block markers are line-anchored, so they have to go before the whitespace
+  // collapse, and before `stripMarkdown` (whose inline-code rule would chew a
+  // fence into a stray backtick). Ordered markers matter most: the seed prompt
+  // asks the model for numbered lists, and a leading `1.` also reads as a
+  // sentence terminator, which would truncate the title to the first digit.
+  // The leading-space allowance and rule set mirror `flattenToPlainText` in
+  // workspace migration 138, which must stay self-contained and so cannot share
+  // this code. A backfilled title and a freshly written one have to match.
+  const deblocked = summary
+    .replace(/^\s{0,3}(?:```|~~~).*$/gm, "")
+    .replace(/^\s{0,3}#{1,6}\s+/gm, "")
+    .replace(/^\s{0,3}>\s?/gm, "")
+    .replace(/^\s{0,3}(?:[-*+]|\d+[.)])\s+/gm, "");
+  const plain = flattenWhitespace(stripMarkdown(deblocked));
+  return deriveTitle(plain || flattenWhitespace(summary));
+}
+
+/** Collapse whitespace runs, including hard line breaks, into single spaces. */
+function flattenWhitespace(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
 // ── Category & detail-panel derivation ────────────────────────────────
 
 const EVENT_CATEGORY_MAP: Record<string, FeedItemCategory> = {