@flamingo-stack/openframe-frontend-core 0.0.510 → 0.0.511

package/dist/utils/list-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-url.d.ts","sourceRoot":"","sources":["../../src/utils/list-url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAWH;;;;iEAIiE;AACjE,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEtE;AA6BD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,SAAK,GAAG,MAAM,GAAG,IAAI,CAa5F"}
+{"version":3,"file":"list-url.d.ts","sourceRoot":"","sources":["../../src/utils/list-url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAWH;;;;iEAIiE;AACjE,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAOtE;AA6BD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,SAAK,GAAG,MAAM,GAAG,IAAI,CAa5F"}

package/dist/utils/same-page-hash-nav.d.ts

@@ -15,12 +15,23 @@ export declare const HUB_HEADER_OFFSET_PX = 80;
  */
 export declare function normalizeHashFragment(hash: string): string;
 /**
- * Resolve the DOM element a hash fragment id points at. Tries the raw
- * id first (ordinary anchors), then the percent-decoded form — href
- * composers like `buildTicketOpenHref` encode the id into the fragment
- * while rows render the raw id, so `#ticket-a%2Fb` must still find
- * `id="ticket-a/b"`. A malformed escape sequence falls back to the
- * raw lookup result.
+ * Resolve the DOM element a hash fragment id points at — THE hash resolver;
+ * `navigateSamePageHash`, `useScrollToHash` and the markdown link renderer
+ * all go through this one, so a fragment that resolves for a deep link
+ * resolves for an in-body click too.
+ *
+ * Three passes, cheapest first:
+ *   1. the raw id (ordinary anchors — the overwhelming common case);
+ *   2. the percent-decoded form — href composers like `buildTicketOpenHref`
+ *      encode the id into the fragment while rows render the raw id, so
+ *      `#ticket-a%2Fb` must still find `id="ticket-a/b"`. A malformed escape
+ *      sequence just falls through;
+ *   3. a NORMALIZED match against the document's headings — doc bodies are
+ *      authored on GitHub, whose slugger keeps the hyphen left behind by a
+ *      stripped emoji (`## 📚 Table of Contents` → `#-table-of-contents`)
+ *      while our ids trim it. Without this every in-body TOC link in every
+ *      GitHub-authored doc resolves to nothing and clicking one does nothing.
+ *      See `utils/anchor-id`.
  */
 export declare function getHashTargetElement(id: string): HTMLElement | null;
 export interface NavigateSamePageHashOptions {

package/dist/utils/same-page-hash-nav.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"same-page-hash-nav.d.ts","sourceRoot":"","sources":["../../src/utils/same-page-hash-nav.ts"],"names":[],"mappings":"AAEA;;sCAEsC;AACtC,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC;yCACyC;AACzC,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI1D;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAWnE;AAED,MAAM,WAAW,2BAA2B;IAC1C,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;gEAC4D;IAC5D,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAkET"}
+{"version":3,"file":"same-page-hash-nav.d.ts","sourceRoot":"","sources":["../../src/utils/same-page-hash-nav.ts"],"names":[],"mappings":"AAGA;;sCAEsC;AACtC,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC;yCACyC;AACzC,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI1D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAkBnE;AAED,MAAM,WAAW,2BAA2B;IAC1C,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;gEAC4D;IAC5D,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAkET"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flamingo-stack/openframe-frontend-core",
-  "version": "0.0.510",
+  "version": "0.0.511",
   "description": "Shared design system and components for all Flamingo platforms",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/chat/__tests__/remark-mention-chips.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest'
+import type { Root, Text, Link, Paragraph } from 'mdast'
+import { remarkMentionChips } from '../remark-mention-chips'
+
+/** One-paragraph tree holding a single text leaf — what the plugin walks. */
+function treeOf(text: string): Root {
+  return { type: 'root', children: [{ type: 'paragraph', children: [{ type: 'text', value: text }] }] }
+}
+
+/**
+ * unified's `Plugin` type declares a `this: Processor` parameter, so calling the
+ * attacher bare (outside a pipeline) is a TS2684 — cast the attacher itself, not
+ * just its return value, to drop that `this`.
+ */
+const attach = remarkMentionChips as unknown as () => (t: Root) => void
+
+function run(text: string): Array<Text | Link> {
+  const tree = treeOf(text)
+  attach()(tree)
+  return (tree.children[0] as Paragraph).children as Array<Text | Link>
+}
+
+/** `mention://marker:id` urls the plugin emitted, in order. */
+function mentions(text: string): string[] {
+  return run(text).flatMap((n) => (n.type === 'link' ? [n.url] : []))
+}
+
+describe('remarkMentionChips markers', () => {
+  it('parses the lowercase markers', () => {
+    expect(mentions('see @device:64f0a1 and @kb:5')).toEqual([
+      'mention://device:64f0a1',
+      'mention://kb:5',
+    ])
+  })
+
+  it('parses a camelCase marker', () => {
+    // Regression: `ContextItemType.SCHEDULED_SCRIPT` ships as `scheduledScript`,
+    // and a lowercase-only grammar matched NOTHING in the token — the mention
+    // silently stayed raw text in the bubble instead of becoming a chip.
+    expect(mentions('run @scheduledScript:6a6c9342f8e10b2477900c08 now')).toEqual([
+      'mention://scheduledScript:6a6c9342f8e10b2477900c08',
+    ])
+  })
+
+  it('keeps the surrounding text intact around a camelCase mention', () => {
+    const parts = run('run @scheduledScript:6a6c9342f8e10b2477900c08 now')
+    expect(parts.map((n) => (n.type === 'text' ? n.value : `[${(n as Link).url}]`))).toEqual([
+      'run ',
+      '[mention://scheduledScript:6a6c9342f8e10b2477900c08]',
+      ' now',
+    ])
+  })
+
+  it('fires inside punctuation but never mid-word', () => {
+    expect(mentions('(@scheduledScript:6a6c9342f8e10b2477900c08)')).toEqual([
+      'mention://scheduledScript:6a6c9342f8e10b2477900c08',
+    ])
+    // An email-shaped host:port is not a mention — the `@` is preceded by a word char.
+    expect(mentions('mail user@Host:1234 stays text')).toEqual([])
+  })
+
+  it('leaves a trailing sentence period out of the id', () => {
+    expect(mentions('ran @scheduledScript:6a6c9342f8e10b2477900c08.')).toEqual([
+      'mention://scheduledScript:6a6c9342f8e10b2477900c08',
+    ])
+  })
+})

package/src/components/chat/chat-message-enhanced.tsx

@@ -27,8 +27,9 @@ import type { MessageSegment, MessageContent, ChatMessageEnhancedProps } from ".
  *  (e.g. it matches `x@device:1` mid-word, which the plugin skips), so a context
  *  item would be stripped from the chip strip yet never rendered inline — lost
  *  from display entirely. The id is capture group 2 (group 1 is the boundary).
- *  Marker lowercase; id is the mention-token charset. */
-const MENTION_MARKER_REGEX = /(^|[^\w@])@[a-z]+:([A-Za-z0-9_.+/=-]*[A-Za-z0-9_+/=])/g
+ *  Marker `[a-zA-Z]+` (markers are mostly lowercase but not all — e.g.
+ *  `scheduledScript`); id is the mention-token charset. */
+const MENTION_MARKER_REGEX = /(^|[^\w@])@[a-zA-Z]+:([A-Za-z0-9_.+/=-]*[A-Za-z0-9_+/=])/g
 
 /**
  * Same regex shape as `remarkCardLinks` — kept in lockstep so the

package/src/components/chat/chat-message-list.tsx

@@ -6,6 +6,7 @@ import { cn } from "../../utils/cn"
 import { ChatMessageEnhanced } from "./chat-message-enhanced"
 import { ChatMessageListSkeleton } from "./chat-message-skeleton"
 import { DotsLoaderIcon, Arrow02DownIcon } from "../icons-v2-generated"
+import { OverlayOpenRegistryProvider } from "../ui/overlay-open-registry"
 import { CyclingPhrase } from "./cycling-phrase"
 import type { ChatMessageListProps } from "./types"
 import { SCROLL_ANCHOR } from "./types/message.types"
@@ -141,10 +142,44 @@ const ChatMessageList = forwardRef<HTMLDivElement, ChatMessageListProps>(
     // effect below owns first-paint positioning so re-opening a chat
     // with prior history lands at the bottom without a smooth-scroll
     // animation playing over the cold-paint.
-    const { scrollRef, contentRef, scrollToBottom, stopScroll } = useStickToBottom({
-      resize: 'smooth',
-      initial: false,
-    })
+    const { scrollRef, contentRef, scrollToBottom, stopScroll, isAtBottom } =
+      useStickToBottom({
+        resize: 'smooth',
+        initial: false,
+      })
+
+    // ---- Overlay guard: don't move the ground under an open menu -------
+    // A ⋯ menu inside a bubble stays anchored to its trigger. While a reply
+    // streams in, the follow-the-bottom scroll carries that trigger upward and
+    // drags the menu with it, until the menu sits at the panel edge detached
+    // from its card. So: while any overlay in this thread is open, stop
+    // chasing the bottom (the same thing ChatGPT/Claude do once you interact
+    // with the transcript), then catch up on close if we were at the bottom
+    // when it opened. New content still renders — we simply stop scrolling to
+    // it, and the existing "scroll to bottom" affordance stays available.
+    const overlayOpenRef = useRef(false)
+    const wasAtBottomOnOpenRef = useRef(false)
+    const isAtBottomRef = useRef(isAtBottom)
+    isAtBottomRef.current = isAtBottom
+    const handleOverlayOpenChange = useCallback(
+      (hasOpenOverlay: boolean) => {
+        overlayOpenRef.current = hasOpenOverlay
+        if (hasOpenOverlay) {
+          wasAtBottomOnOpenRef.current = isAtBottomRef.current
+          // Cancel any in-flight spring so the thread settles immediately
+          // instead of drifting for another few hundred ms under the menu.
+          stopScroll()
+          return
+        }
+        // Closed again: resume only if the reader was pinned to the bottom
+        // before opening it. Someone who had scrolled up to read history keeps
+        // their position.
+        if (wasAtBottomOnOpenRef.current) {
+          void scrollToBottom({ animation: 'smooth' })
+        }
+      },
+      [scrollToBottom, stopScroll],
+    )
 
     // ---- Prepend / load-more state (NOT owned by the library) --------
     const sentinelRef = useRef<HTMLDivElement>(null)
@@ -263,7 +298,12 @@ const ChatMessageList = forwardRef<HTMLDivElement, ChatMessageListProps>(
         const prevLastIdx = prevLastId ? messages.findIndex((m) => m.id === prevLastId) : -1
         const newSlice = prevLastIdx >= 0 ? messages.slice(prevLastIdx + 1) : messages.slice(prevCount)
         const hasNewUser = newSlice.some((m) => m.role === 'user')
-        if (hasNewUser) {
+        // An open overlay suppresses even this one: `ignoreEscapes` would yank
+        // the thread out from under it — and with it the follow intent, which
+        // would re-assert the jump on every later resize. A user who just sent
+        // a message with a menu open is rare; a menu jumping away mid-click is
+        // not worth it.
+        if (hasNewUser && !overlayOpenRef.current) {
           // Arms the follow intent for the WHOLE turn: the answer's
           // async growth (attachment images, streamed tokens, entity
           // cards resolving out of their skeletons long after the
@@ -657,6 +697,8 @@ const ChatMessageList = forwardRef<HTMLDivElement, ChatMessageListProps>(
 
     useLayoutEffect(() => {
       if (!autoScroll) return
+      // Top-anchored display turns also move the ground — same guard.
+      if (overlayOpenRef.current) return
       const last = messages[messages.length - 1]
       if (!last || last.role !== 'assistant' || last.scrollAnchor !== SCROLL_ANCHOR.TOP) return
       // Metadata frame arrives BEFORE body. Wait for content so we don't
@@ -847,6 +889,7 @@ const ChatMessageList = forwardRef<HTMLDivElement, ChatMessageListProps>(
       !(pendingApprovals && pendingApprovals.length > 0)
 
     return (
+      <OverlayOpenRegistryProvider onOpenChange={handleOverlayOpenChange}>
       <div className="flex-1 min-h-0 flex flex-col">
         {/* Positioning box for the jump-to-bottom button: it wraps ONLY the
             scroller, so `absolute bottom-…` really is the scroller's lower
@@ -1029,6 +1072,7 @@ const ChatMessageList = forwardRef<HTMLDivElement, ChatMessageListProps>(
           </div>
         )}
       </div>
+      </OverlayOpenRegistryProvider>
     )
   },
 )

package/src/components/chat/embeddable-chat.tsx

@@ -52,7 +52,7 @@ import { MingoHistoryRail } from './mingo-history-rail'
 import { GuideWelcome, type GuideWelcomeProps } from './guide-welcome'
 import { accentFromIdentityIcon, getAgentAccent } from './quick-action-chip'
 import { GuideModeBanner } from './guide-mode-banner'
-import { PortalContainerContext } from '../ui/portal-container'
+import { CollisionBoundaryContext, PortalContainerContext } from '../ui/portal-container'
 import { ChatPanelHeader, type ChatPanelHeaderProps } from './chat-panel-header'
 import { SquareAvatar } from '../ui/square-avatar'
 import { ChatHeaderIconButton } from './chat-header-icon-button'
@@ -1795,6 +1795,13 @@ function EmbeddableChatInner({
 
   // Host node for in-panel Radix portals (see the body wrapper below).
   const [portalHost, setPortalHost] = useState<HTMLDivElement | null>(null)
+  // The panel element itself, published as the COLLISION boundary for overlays
+  // opened inside it. Radix otherwise collides against the viewport, so a ⋯ menu
+  // near the top of the thread flips upward past the panel and renders over the
+  // app header (reported: an entity card's menu landing in the top-right corner,
+  // detached from its card). `portalHost` can't serve here — it is
+  // `display: contents` and has no box to measure.
+  const [panelBoundary, setPanelBoundary] = useState<HTMLDivElement | null>(null)
 
   // ── Split (wide) Mingo layout ─────────────────────────────────────────────
   // The panel measures its own width and, in Mingo mode, promotes the inline
@@ -1817,6 +1824,14 @@ function EmbeddableChatInner({
     return () => ro.disconnect()
   }, [])
 
+  // One ref for two consumers: the width measurement above (a plain ref, read
+  // once on mount) and the collision-boundary context (state, so provider
+  // consumers re-render once the node exists).
+  const setPanelNode = useCallback((node: HTMLDivElement | null) => {
+    panelMeasureRef.current = node
+    setPanelBoundary(node)
+  }, [])
+
   // Rail collapse toggle (Figma ⟶| control), persisted so it survives the
   // drawer remounting on close.
   const [railCollapsed, setRailCollapsed] = useState(false)
@@ -2003,6 +2018,7 @@ function EmbeddableChatInner({
   // document root. See `PortalContainerContext`.
   const body = (
         <PortalContainerContext.Provider value={portalHost}>
+         <CollisionBoundaryContext.Provider value={panelBoundary}>
             {/* Panel surface depends on state (Figma):
                   • Narrow "Current Chats" LIST + FULL-PANEL archive page → grey
                     `ods-card` (#212121) — matching the grey rail those lists live
@@ -2017,7 +2033,7 @@ function EmbeddableChatInner({
                 grey), so the chat block on the right must keep the conversation's
                 dark surface instead of following the archive. */}
             <div
-              ref={panelMeasureRef}
+              ref={setPanelNode}
               className={`flex h-full flex-col overflow-hidden transition-colors duration-200 ${
                 (archiveOpen && !splitActive) || stackedListView
                   ? 'bg-ods-card'
@@ -2587,6 +2603,7 @@ function EmbeddableChatInner({
             {/* Portal target for in-panel Radix overlays — `display: contents`
                 so it adds no box; content is positioned `fixed` by Radix. */}
             <div ref={setPortalHost} style={{ display: 'contents' }} />
+         </CollisionBoundaryContext.Provider>
           </PortalContainerContext.Provider>
   )
 

package/src/components/chat/entity-cards/dispatch.tsx

@@ -36,6 +36,7 @@ import type { ChatRef } from '../chat-ref.types'
 import { useChatCardItem } from '../hooks/use-chat-card-item'
 import { handleChatNavClick } from '../utils/nav-click-handler'
 import { resolveSourceRowCTA, resolveSourceIcon, sourceRowCtxFromRuntime } from '../utils/source-row-cta'
+import { resolveFetchedCardHref, readFetchedCardTitle } from '../utils/resolve-fetched-card-href'
 import { resolveHrefForRuntime } from '../utils/chat-nav-resolution'
 import {
   computeIsNewTab,
@@ -1000,8 +1001,15 @@ type ChatCardRegistryEntry =
        *  resolved ref — so the wrapper sees a non-null `href`, the
        *  pre-computed `isNewTab` reflects the actual destination, and
        *  the click goes through `handleChatNavClick` (no silent
-       *  bypass of embed-mode / close-on-nav). */
+       *  bypass of embed-mode / close-on-nav). Takes precedence over the
+       *  `composeContentUrl` fallback below. */
       fallbackHref?: (item: any) => string | null
+      /** Opt OUT of the post-fetch `composeContentUrl` fallback (see
+       *  `resolveFetchedCardHref`). Set for types with NO public destination
+       *  — the seam would otherwise synthesize `<contentOrigin>/<type>/<id>`
+       *  from its default branch and hand the user a 404. Types with a real
+       *  route (hosted, or covered by a host `override`) leave it unset. */
+      noComposedHref?: boolean
     }
 
 interface FinancialCardConfig {
@@ -1106,6 +1114,8 @@ interface RoadmapEntryConfig {
   label: string
   cardType: RoadmapCardType
   contentRefType: string
+  /** See `ChatCardRegistryEntry.noComposedHref`. */
+  noComposedHref?: boolean
 }
 const ROADMAP_CARD_CONFIGS: Record<string, RoadmapEntryConfig> = {
   roadmap_item: { label: 'Roadmap item', cardType: 'roadmap_item', contentRefType: 'roadmap_item' },
@@ -1118,6 +1128,9 @@ const ROADMAP_CARD_CONFIGS: Record<string, RoadmapEntryConfig> = {
     label: 'Internal task',
     cardType: 'internal_task',
     contentRefType: 'internal_task',
+    // Internal ClickUp work has no public destination on any platform — the
+    // seam's default branch would synthesize `<hub>/internal_task/<id>`.
+    noComposedHref: true,
   },
 }
 function roadmapRegistryEntries(): Record<string, ChatCardRegistryEntry> {
@@ -1128,6 +1141,7 @@ function roadmapRegistryEntries(): Record<string, ChatCardRegistryEntry> {
       label: cfg.label,
       contentRefType: cfg.contentRefType,
       bareInline: true,
+      ...(cfg.noComposedHref ? { noComposedHref: true } : {}),
       skeleton: () => <RoadmapCardSkeleton size="sm" />,
       render: (item, chatRef, opts) => (
         <RoadmapChatCard
@@ -1420,6 +1434,17 @@ function ChatCardNavWrap({
   const onClickCapture = (e: React.MouseEvent<HTMLElement>) => {
     if (!href) return
     const targetEl = e.target as HTMLElement
+    // Only claim clicks that physically happened INSIDE this card.
+    //
+    // The card's "⋯" menu renders through a React PORTAL: its DOM lives in the
+    // panel's portal host, but React still bubbles its events through this
+    // subtree — so this capture handler sees them first and, being a capture
+    // phase, runs BEFORE the menu row's own `stopPropagation`. That swallowed
+    // the menu's trailing "↗ Open in new tab" button: `executeNavigation`
+    // called `preventDefault()` and routed the card's href in the SAME tab,
+    // so the anchor's `target="_blank"` never applied.
+    const host = e.currentTarget as HTMLElement | null
+    if (!host?.contains(targetEl)) return
     // Buttons rendered INSIDE the card's outer `<a>` (e.g. RoadmapCard
     // vote buttons, ImageGallery thumbnails) bubble up with
     // `closest('a')` truthy — without this guard, clicking them would
@@ -1522,18 +1547,54 @@ export function ChatCardLoader({
   )
   if (!entry) return null
 
-  // Apply per-type fallback URL AFTER fetch (e.g. campaign → /admin/...).
+  // Apply the post-fetch URL fallback (the ref carried no `externalUrl`).
   // We mutate `resolvedChatRef.url` BEFORE computing isNewTab so the
   // wrapper's interceptor sees the destination the user will actually
   // visit. `safeHref` blocks `javascript:` / `data:` payloads even
   // though the registry callers compose hub-internal strings today.
-  const finalChatRef: ChatRef =
+  //
+  // Two sources, in order:
+  //   1. the registry's per-type `fallbackHref` — an explicit non-content
+  //      destination (marketing campaign → `/admin/...`);
+  //   2. the host's `composeContentUrl` seam via `resolveFetchedCardHref` —
+  //      the SAME resolver page cards and SSE chat cards go through. This is
+  //      what makes Mingo/NATS cards clickable: that transport ships bare
+  //      `[card://type:id]` markers with no refs metadata, so the ref reaches
+  //      us with `url: null` and `resolveSourceRowCTA` has nothing to route.
+  const composedHref =
+    fetchEntry && !resolvedChatRef.url && item && !fetchEntry.fallbackHref && !fetchEntry.noComposedHref
+      ? resolveFetchedCardHref({
+          contentRefType: fetchEntry.contentRefType,
+          id: resolvedChatRef.id,
+          item,
+          composeContentUrl: runtime.composeContentUrl,
+        })
+      : null
+  const hrefResolvedChatRef: ChatRef =
     fetchEntry && !resolvedChatRef.url && item && fetchEntry.fallbackHref
       ? {
           ...resolvedChatRef,
           url: safeHref(fetchEntry.fallbackHref(item)),
         }
-      : resolvedChatRef
+      : composedHref
+        ? {
+            ...resolvedChatRef,
+            url: safeHref(composedHref.href),
+            targetPlatform: composedHref.targetPlatform ?? resolvedChatRef.targetPlatform ?? null,
+          }
+        : resolvedChatRef
+
+  // Title enrichment, same synthetic-ref gap as the href above: a Mingo
+  // `[card://type:id]` marker produces `title: <id>` because the transport
+  // ships no ref metadata. Downstream consumers that read `ref.title` — most
+  // visibly the "Ask Mingo" prompt, which would otherwise send
+  // "Tell me more about 86ad3qvv5" — get the row's real title once it loads.
+  // A ref that already carries a distinct title (the SSE path) is untouched.
+  const fetchedTitle = fetchEntry && item ? readFetchedCardTitle(item) : null
+  const finalChatRef: ChatRef =
+    fetchedTitle && (!hrefResolvedChatRef.title || hrefResolvedChatRef.title === hrefResolvedChatRef.id)
+      ? { ...hrefResolvedChatRef, title: fetchedTitle }
+      : hrefResolvedChatRef
 
   // Pre-compute new-tab decision ONCE here (the same rule chips use).
   // Render branches that pass `target` / `rel` to their card pull this

package/src/components/chat/hooks/use-nats-chat-adapter.ts

@@ -56,6 +56,7 @@ import { createChatDialogStore, DEFAULT_DIALOG_SIDE } from '../stream/chat-dialo
 import { useChatStreamReducer } from '../stream/use-chat-stream-reducer'
 import { processHistoricalMessagesWithErrors } from '../utils/process-historical-messages'
 import { extractIncompleteTailState } from '../utils/extract-incomplete-message-state'
+import { buildDiscussPrompt } from '../utils/discuss-ref-prompt'
 import type {
   ChunkData,
   FetchChunksFunction,
@@ -1076,10 +1077,33 @@ export function useNatsChatAdapter(
     [],
   )
 
-  // No-op refs — Mingo agent has no RAG entity-card affordances.
-  const discussRef = useCallback((_ref: ChatRef) => {
-    /* no-op in Mingo mode */
-  }, [])
+  // "Ask Mingo" on an inline entity card. The agent transport has NO
+  // entity-id-filtered retrieval (its `ContextItemType` enum covers DEVICE /
+  // SCRIPT / TICKET / ORGANIZATION / USER / KB_ARTICLE / POLICY / QUERY /
+  // SCHEDULED_SCRIPT — no content types), so unlike the SSE path there is no
+  // `commandOverride.entityIdFilter` to send: the prompt carries the type + id
+  // as text and the agent resolves the row itself. Same sentence as guide mode
+  // (shared builder) so the affordance reads identically in both.
+  //
+  // This used to be a no-op, which made the card's "Ask Mingo" menu item dead
+  // in Mingo mode. Swap `includeReference` for a structured filter once the
+  // agent backend accepts one.
+  const discussRef = useCallback(
+    (reference: ChatRef) => {
+      const prompt = buildDiscussPrompt(reference, { includeReference: true })
+      // Menu-item click, so there is no composer promise for the rejection to
+      // surface through — a bare `void` would leave it unhandled. Logged in the
+      // same shape as `stopMessage`'s. NOTE: recovering the optimistic rows and
+      // the stuck `thinking` phase after a failed publish is a `sendMessage`
+      // concern (it affects composer sends identically) and is not done here.
+      void sendMessage(prompt).catch((err) => {
+        console.error('[useNatsChatAdapter] discussRef send failed:', err)
+      })
+    },
+    [sendMessage],
+  )
+  // Display stays a no-op: it dispatches a `/…  display "<x>"` slash command,
+  // and the agent transport has no slash-command registry.
   const displayRef = useCallback((_ref: ChatRef) => {
     /* no-op in Mingo mode */
   }, [])

package/src/components/chat/hooks/use-sse-chat-adapter.ts

@@ -67,6 +67,7 @@ import {
 } from '../utils/chat-conversation-storage'
 import { useChatHistoryHydration } from './use-chat-history-hydration'
 import { sanitizeTitleForChat } from '../utils/slash-dispatch-utils'
+import { buildDiscussPrompt } from '../utils/discuss-ref-prompt'
 import { defaultTableIdForDocumentType } from '../utils/source-icons'
 import type { WireCommandOverride } from '../utils/slash-dispatch-utils'
 import type { ChatAttachment } from '../utils/chat-attachment-markdown'
@@ -657,9 +658,10 @@ export function useSseChatAdapter(
       }
       // RETRIEVAL IS STRICTLY PRIMARY-KEY-DRIVEN. The visible prose
       // ("Tell me more about <title>") is UX-only; retrieval narrows
-      // via `entityIdFilter` before the LLM is invoked.
-      const sanitizedTitle = sanitizeTitleForChat(reference.title)
-      const prompt = `Tell me more about ${sanitizedTitle || 'this item'}`
+      // via `entityIdFilter` before the LLM is invoked. The sentence itself
+      // comes from the shared builder so the Mingo transport (which has no
+      // id filter and leans on the prose) phrases it identically.
+      const prompt = buildDiscussPrompt(reference)
       sendMessage(prompt, {
         commandOverride: { entityIdFilter: { tableId, id: refId } },
       })

package/src/components/chat/remark-mention-chips.ts

@@ -15,9 +15,12 @@
  * intact, and the marker disappears before any rehype-raw HTML pass.
  *
  * Grammar:
- *   - marker: `[a-z]+` — the backend `ContextItemType.marker()` short form
+ *   - marker: `[a-zA-Z]+` — the backend `ContextItemType.marker()` short form
  *     (`device`, `script`, `ticket`, `organization`, `user`, `kb`, `policy`,
- *     `query`, …). Always lowercase.
+ *     `query`, `scheduledScript`, …). Mostly lowercase, but NOT guaranteed to be:
+ *     the marker is matched verbatim by the backend's `MentionParser`, and
+ *     `SCHEDULED_SCRIPT` ships as camelCase `scheduledScript` — a lowercase-only
+ *     grammar silently dropped that whole token (no chip, raw text in the bubble).
  *   - id: charset `[A-Za-z0-9_.+/=-]` (UUIDs with hyphens, fleet numeric ids,
  *     base64 global ids, etc.; matches the composer's `MENTION_TOKEN`) — but the
  *     id may NOT END in `.` or `-`, so a trailing SENTENCE period/dash isn't
@@ -35,7 +38,7 @@ import type { Plugin } from 'unified'
 import type { Root, Text, Link } from 'mdast'
 import { visit, SKIP } from 'unist-util-visit'
 
-const MENTION_REGEX = /(^|[^\w@])@([a-z]+):([A-Za-z0-9_.+/=-]*[A-Za-z0-9_+/=])/g
+const MENTION_REGEX = /(^|[^\w@])@([a-zA-Z]+):([A-Za-z0-9_.+/=-]*[A-Za-z0-9_+/=])/g
 
 export const remarkMentionChips: Plugin<[], Root> = () => {
   return (tree: Root) => {

package/src/components/chat/utils/__tests__/discuss-ref-prompt.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+import { buildDiscussPrompt } from '../discuss-ref-prompt'
+import { readFetchedCardTitle } from '../resolve-fetched-card-href'
+
+const ROADMAP_REF = {
+  type: 'roadmap_item',
+  id: '86ad3qvv5',
+  title: 'Deep Google Workspace tenant management',
+}
+
+describe('buildDiscussPrompt', () => {
+  it('guide/SSE shape — prose only, retrieval rides entityIdFilter', () => {
+    expect(buildDiscussPrompt(ROADMAP_REF)).toBe(
+      'Tell me more about Deep Google Workspace tenant management',
+    )
+  })
+
+  it('Mingo shape — appends the reference the agent has no filter for', () => {
+    expect(buildDiscussPrompt(ROADMAP_REF, { includeReference: true })).toBe(
+      'Tell me more about Deep Google Workspace tenant management (roadmap_item 86ad3qvv5)',
+    )
+  })
+
+  it('a synthetic ref (title === id) never leaks the id as the subject', () => {
+    const synthetic = { type: 'roadmap_item', id: '86ad3qvv5', title: '86ad3qvv5' }
+    expect(buildDiscussPrompt(synthetic, { includeReference: true })).toBe(
+      'Tell me more about this item (roadmap_item 86ad3qvv5)',
+    )
+  })
+
+  it('missing / blank title falls back to "this item"', () => {
+    expect(buildDiscussPrompt({ type: 'blog_post', id: 'b1' })).toBe('Tell me more about this item')
+    expect(buildDiscussPrompt({ type: 'blog_post', id: 'b1', title: '   ' })).toBe(
+      'Tell me more about this item',
+    )
+  })
+
+  it('no id → no reference suffix', () => {
+    expect(buildDiscussPrompt({ type: 'blog_post', id: '', title: 'Hello' }, { includeReference: true })).toBe(
+      'Tell me more about Hello',
+    )
+  })
+})
+
+describe('readFetchedCardTitle — what upgrades a synthetic ref before the prompt', () => {
+  it('prefers title, then name', () => {
+    expect(readFetchedCardTitle({ title: 'Roadmap row' })).toBe('Roadmap row')
+    expect(readFetchedCardTitle({ name: 'Named row' })).toBe('Named row')
+    expect(readFetchedCardTitle({ title: '  ', name: 'Named row' })).toBe('Named row')
+  })
+
+  it('null for rows with neither (and for non-objects)', () => {
+    expect(readFetchedCardTitle({ headline: 'nope' })).toBeNull()
+    expect(readFetchedCardTitle(null)).toBeNull()
+    expect(readFetchedCardTitle('string')).toBeNull()
+    expect(readFetchedCardTitle({ title: 42 })).toBeNull()
+  })
+
+  it('end to end: fetched row title reaches the prompt', () => {
+    const synthetic = { type: 'roadmap_item', id: '86ad3qvv5', title: '86ad3qvv5' }
+    const row = { id: 'db-9', title: 'Deep Google Workspace tenant management' }
+    const enriched = { ...synthetic, title: readFetchedCardTitle(row) ?? synthetic.title }
+    expect(buildDiscussPrompt(enriched, { includeReference: true })).toBe(
+      'Tell me more about Deep Google Workspace tenant management (roadmap_item 86ad3qvv5)',
+    )
+  })
+})