@flamingo-stack/openframe-frontend-core 0.0.510 → 0.0.511-snapshot.20260804140004

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,
@@ -48,6 +49,7 @@ import { SourceActionButton } from '../source-action-button'
 import { NavLinkAnchorViaRuntime } from '../nav-link-anchor-via-runtime'
 import { defaultBuildProductReleaseCardProps } from './product-release-card-defaults'
 import { ChatVideoEntityCard } from './chat-video-entity-card'
+import { DeletedDataCard } from './deleted-data-card'
 import { BlockCard } from './block-card'
 import { BlogCardSkeleton } from './blog-card'
 import { CaseStudyCardSkeleton } from './case-study-card'
@@ -1000,8 +1002,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 {
@@ -1017,26 +1026,34 @@ const FINANCIAL_CARD_CONFIGS: Record<string, FinancialCardConfig> = {
   balance_sheet: { label: 'Balance sheet', icon: () => <BankIcon size={24} /> },
   cash_flow: { label: 'Cash flow', icon: () => <CoinsExchangeCurrencyIcon size={24} /> },
 }
-function financialRegistryEntries(): Record<string, ChatCardRegistryEntry> {
+/** Expand a per-family config map into registry entries — ONE loop shell
+ *  for every card family (financial, github, program, roadmap); adding a
+ *  family is a config map + one `registryEntries(...)` call. */
+function registryEntries<C>(
+  configs: Record<string, C>,
+  build: (cfg: C) => ChatCardRegistryEntry,
+): Record<string, ChatCardRegistryEntry> {
   const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(FINANCIAL_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'no-fetch',
-      label: cfg.label,
-      bareInline: true,
-      render: (chatRef, opts) => (
-        <GenericFinancialChatCard
-          chatRef={chatRef}
-          icon={cfg.icon()}
-          isNewTab={opts.isNewTab}
-          discuss={opts.discuss}
-        />
-      ),
-    }
-  }
+  for (const [docType, cfg] of Object.entries(configs)) out[docType] = build(cfg)
   return out
 }
 
+function financialRegistryEntries(): Record<string, ChatCardRegistryEntry> {
+  return registryEntries(FINANCIAL_CARD_CONFIGS, (cfg) => ({
+    mode: 'no-fetch',
+    label: cfg.label,
+    bareInline: true,
+    render: (chatRef, opts) => (
+      <GenericFinancialChatCard
+        chatRef={chatRef}
+        icon={cfg.icon()}
+        isNewTab={opts.isNewTab}
+        discuss={opts.discuss}
+      />
+    ),
+  }))
+}
+
 interface GitHubCardConfig {
   label: string
   kind: GitHubActivityKind
@@ -1050,19 +1067,15 @@ const GITHUB_CARD_CONFIGS: Record<string, GitHubCardConfig> = {
   github_pr_review_public: { label: 'GitHub review (public)', kind: 'pr_review' },
 }
 function githubRegistryEntries(): Record<string, ChatCardRegistryEntry> {
-  const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(GITHUB_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'no-fetch',
-      label: cfg.label,
-      bareInline: true,
-      render: (chatRef, opts) => (
-        <GitHubChatCard chatRef={chatRef} kind={cfg.kind} isNewTab={opts.isNewTab}
-          discuss={opts.discuss} />
-      ),
-    }
-  }
-  return out
+  return registryEntries(GITHUB_CARD_CONFIGS, (cfg) => ({
+    mode: 'no-fetch',
+    label: cfg.label,
+    bareInline: true,
+    render: (chatRef, opts) => (
+      <GitHubChatCard chatRef={chatRef} kind={cfg.kind} isNewTab={opts.isNewTab}
+        discuss={opts.discuss} />
+    ),
+  }))
 }
 
 type ProgramConfigKey = 'podcast' | 'webinar' | 'event'
@@ -1077,28 +1090,24 @@ const PROGRAM_CARD_CONFIGS: Record<string, ProgramCardConfig> = {
   event: { label: 'Event', configKey: 'event', contentRefType: 'event' },
 }
 function programRegistryEntries(): Record<string, ChatCardRegistryEntry> {
-  const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(PROGRAM_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'fetch',
-      label: cfg.label,
-      contentRefType: cfg.contentRefType,
-      bareInline: true,
-      skeleton: () => <ProgramCardSkeleton size="sm" />,
-      render: (item, chatRef, opts) => (
-        <ProgramChatCard
-          item={item}
-          chatRef={chatRef}
-          isNewTab={opts.isNewTab}
-          discuss={opts.discuss}
-          configKey={cfg.configKey}
-          label={cfg.configKey.charAt(0).toUpperCase() + cfg.configKey.slice(1)}
-          ogPlaceholder={opts?.extras?.buildOgPlaceholderUrl?.(item?.title ?? '') ?? null}
-        />
-      ),
-    }
-  }
-  return out
+  return registryEntries(PROGRAM_CARD_CONFIGS, (cfg) => ({
+    mode: 'fetch',
+    label: cfg.label,
+    contentRefType: cfg.contentRefType,
+    bareInline: true,
+    skeleton: () => <ProgramCardSkeleton size="sm" />,
+    render: (item, chatRef, opts) => (
+      <ProgramChatCard
+        item={item}
+        chatRef={chatRef}
+        isNewTab={opts.isNewTab}
+        discuss={opts.discuss}
+        configKey={cfg.configKey}
+        label={cfg.configKey.charAt(0).toUpperCase() + cfg.configKey.slice(1)}
+        ogPlaceholder={opts?.extras?.buildOgPlaceholderUrl?.(item?.title ?? '') ?? null}
+      />
+    ),
+  }))
 }
 
 type RoadmapCardType = 'roadmap_item' | 'delivery_item' | 'internal_task'
@@ -1106,6 +1115,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,34 +1129,50 @@ 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> {
-  const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(ROADMAP_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'fetch',
-      label: cfg.label,
-      contentRefType: cfg.contentRefType,
-      bareInline: true,
-      skeleton: () => <RoadmapCardSkeleton size="sm" />,
-      render: (item, chatRef, opts) => (
-        <RoadmapChatCard
-          item={item}
-          chatRef={chatRef}
-          isNewTab={opts.isNewTab}
-          discuss={opts.discuss}
-          cardType={cfg.cardType}
-        />
-      ),
-    }
-  }
-  return out
+  return registryEntries(ROADMAP_CARD_CONFIGS, (cfg) => ({
+    mode: 'fetch',
+    label: cfg.label,
+    contentRefType: cfg.contentRefType,
+    bareInline: true,
+    ...(cfg.noComposedHref ? { noComposedHref: true } : {}),
+    skeleton: () => <RoadmapCardSkeleton size="sm" />,
+    render: (item, chatRef, opts) => (
+      <RoadmapChatCard
+        item={item}
+        chatRef={chatRef}
+        isNewTab={opts.isNewTab}
+        discuss={opts.discuss}
+        cardType={cfg.cardType}
+      />
+    ),
+  }))
 }
 
 const CHAT_CARD_REGISTRY: Record<string, ChatCardRegistryEntry> = {
   // ───────── no-fetch: ChatRef carries everything ─────────
   ...githubRegistryEntries(),
+  // Generic TOMBSTONE for entities a chat action deleted (ClickUp task
+  // today; any deletable entity tomorrow). No fetch, no navigation —
+  // the entity no longer resolves anywhere; the placeholder keeps the
+  // thread's integrity (Teams/Slack "This message was deleted" pattern).
+  deleted_data: {
+    mode: 'no-fetch',
+    label: 'Deleted',
+    bareInline: true,
+    render: (chatRef) => (
+      <DeletedDataCard
+        title={chatRef.title ?? null}
+        entityLabel={(chatRef.metadata?.entity_label as string | undefined) ?? null}
+        recoveryNote={(chatRef.metadata?.recovery_note as string | undefined) ?? null}
+      />
+    ),
+  },
   slack_message: {
     mode: 'no-fetch',
     label: 'Slack message',
@@ -1420,6 +1447,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
@@ -1516,24 +1554,60 @@ export function ChatCardLoader({
   // `contentRefType` is empty so the hook returns `isLoading=false` and
   // `item=undefined`, which we ignore.
   const fetchEntry = entry && entry.mode === 'fetch' ? entry : null
-  const { item, isLoading } = useChatCardItem<any>(
+  const { item, isLoading, isError, isFetched } = useChatCardItem<any>(
     fetchEntry?.contentRefType ?? '',
     fetchEntry ? resolvedChatRef.id : '',
   )
   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
@@ -1590,6 +1664,23 @@ export function ChatCardLoader({
       {children}
     </ChatCardNavWrap>
   )
+  // ONE render tail for both modes — bare-inline cards skip the discuss
+  // wrapper; everything else gets the ChatCardWithDiscuss chrome. Kept
+  // here (not per-branch) so the two paths can never drift on the
+  // discuss-menu wiring.
+  const finish = (node: React.ReactNode) =>
+    entry.bareInline ? (
+      <>{navWrap(node)}</>
+    ) : (
+      <ChatCardWithDiscuss
+        chatRef={finalChatRef}
+        onDiscuss={onDiscuss}
+        onDisplay={onDisplay}
+        displayAction={entry.displayAction}
+      >
+        {navWrap(node)}
+      </ChatCardWithDiscuss>
+    )
   if (entry.mode === 'no-fetch') {
     // Synthetic-ref gate. `chat-message-enhanced.tsx` builds a minimal
     // `{ type, id, title: cardId, url: null }` ChatRef when the LLM
@@ -1612,35 +1703,47 @@ export function ChatCardLoader({
     // Fetch-mode types already handle this gracefully: a synthetic
     // id leads to a fetch miss → `!item` → null at line ~1034.
     if (!finalChatRef.sourceRepo) return null
-    if (entry.bareInline) {
-      return navWrap(entry.render(finalChatRef, renderOpts))
-    }
-    return (
-      <ChatCardWithDiscuss
-        chatRef={finalChatRef}
-        onDiscuss={onDiscuss}
-        onDisplay={onDisplay}
-        displayAction={entry.displayAction}
-      >
-        {navWrap(entry.render(finalChatRef, renderOpts))}
-      </ChatCardWithDiscuss>
-    )
+    return finish(entry.render(finalChatRef, renderOpts))
   }
   if (isLoading) return <>{entry.skeleton()}</>
-  if (!item) return null
-  if (entry.bareInline) {
-    return <>{navWrap(entry.render(item, finalChatRef, renderOpts))}</>
+  if (!item) {
+    // FETCH FAILURE (non-OK response — auth blip, 5xx, rate limit) is
+    // NOT evidence of deletion: render nothing rather than a false
+    // "deleted" claim. Only a SUCCESSFUL fetch that lacks the id
+    // reaches the tombstone below.
+    if (isError) return null
+    // NEVER-FETCHED (query disabled — no list URL registered for this
+    // type, or an empty id): no request was made, so absence of `item`
+    // proves nothing. Render nothing rather than a false "deleted".
+    if (!isFetched) return null
+    // FETCH MISS. Two distinct cases, split by ref provenance:
+    //
+    //   - SERVER-BUILT ref (`sourceRepo` present — the entity provably
+    //     existed when the answer was written, its ref was persisted
+    //     with the message): the entity is GONE now (deleted /
+    //     tombstoned). Render the generic deleted-data TOMBSTONE so the
+    //     thread keeps its integrity instead of a silent gap — works
+    //     for ANY fetch-mode entity type, no per-type wiring.
+    //
+    //   - SYNTHETIC client-built ref (bare marker with no refs entry —
+    //     possibly a hallucinated id): keep the existing hide-it
+    //     behavior; a "deleted" placeholder would assert an existence
+    //     we can't vouch for.
+    if (finalChatRef.sourceRepo) {
+      return (
+        <DeletedDataCard
+          title={finalChatRef.title ?? null}
+          entityLabel={entry.label}
+          recoveryNote={
+            (finalChatRef.metadata as Record<string, unknown> | null | undefined)
+              ?.recovery_note as string | undefined ?? null
+          }
+        />
+      )
+    }
+    return null
   }
-  return (
-    <ChatCardWithDiscuss
-      chatRef={finalChatRef}
-      onDiscuss={onDiscuss}
-      onDisplay={onDisplay}
-      displayAction={entry.displayAction}
-    >
-      {navWrap(entry.render(item, finalChatRef, renderOpts))}
-    </ChatCardWithDiscuss>
-  )
+  return finish(entry.render(item, finalChatRef, renderOpts))
 }
 
 // =============================================================================

package/src/components/chat/hooks/__tests__/sse-stream-golden.test.ts

@@ -250,7 +250,7 @@ describe('SSE wire decode — golden fixtures (full hook path)', () => {
     vi.stubGlobal('fetch', fetchMock)
 
     const { result } = renderAdapter()
-    let sendPromise!: Promise<void>
+    let sendPromise!: Promise<void | boolean>
     act(() => {
       sendPromise = result.current.sendMessage('will be aborted')
     })

package/src/components/chat/hooks/use-chat-card-item.ts

@@ -28,6 +28,9 @@ export interface UseChatCardItemResult<T = unknown> {
   item: T | undefined
   isLoading: boolean
   isError: boolean
+  /** True only after a fetch actually completed — false for disabled
+   *  queries (no list URL for the type / empty id). */
+  isFetched: boolean
 }
 
 // `extractItems` / `extractItemId` hoisted to `src/utils/extract-items.ts`
@@ -53,7 +56,12 @@ export function useChatCardItem<T = unknown>(
       // sent no credentials, so list endpoints behind the gateway returned
       // 401 and the card rendered blank.
       const res = await embedAuthedFetch(url)
-      if (!res.ok) return null
+      // THROW on non-OK (was `return null`): callers must be able to
+      // tell "fetched fine, entity absent" (→ deleted tombstone) from
+      // "fetch failed" (401 refresh miss, 5xx, 429 → transient; render
+      // nothing, never a false 'deleted' claim). TanStack surfaces the
+      // throw as `isError`.
+      if (!res.ok) throw new Error(`chat card fetch failed: ${res.status}`)
       const data = await res.json()
       const items = extractItems(data)
       const match = items.find((it) => extractItemId(type, it) === id)
@@ -79,5 +87,11 @@ export function useChatCardItem<T = unknown>(
     item: (query.data ?? undefined) as T | undefined,
     isLoading: query.isLoading,
     isError: query.isError,
+    // True only after the query actually completed a fetch. DISABLED
+    // queries (no list URL registered for the type, empty id) never
+    // fetch — `item` is undefined there as well, and callers must not
+    // read that as "fetched fine, entity absent" (tombstone gate in
+    // entity-cards/dispatch.tsx).
+    isFetched: query.isFetched,
   }
 }

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'
@@ -248,23 +249,26 @@ export function useSseChatAdapter(
   // creation-time callbacks stay stable.
 
   const sendMessageRef = useRef<
-    (text: string, options?: InternalSendMessageOptions) => Promise<void>
-  >(async () => {})
-
-  const cardApprove = useCallback((reqId?: string): void | Promise<void> => {
-    if (!reqId) return
-    return sendMessageRef.current('', {
-      hidden: true,
-      approvalAction: { proposalId: reqId, action: 'approve' },
-    })
-  }, [])
-  const cardReject = useCallback((reqId?: string): void | Promise<void> => {
-    if (!reqId) return
-    return sendMessageRef.current('', {
-      hidden: true,
-      approvalAction: { proposalId: reqId, action: 'reject' },
-    })
-  }, [])
+    (text: string, options?: InternalSendMessageOptions) => Promise<boolean>
+  >(async () => true)
+
+  // Approve/reject pass the transport's boolean outcome through so batch
+  // approve-all loops can mark a FAILED row (expired proposal, network
+  // error) instead of leaving its execution loader spinning. ONE factory
+  // — the two handlers differ only in the action literal.
+  const cardResolve = useCallback(
+    (action: 'approve' | 'reject') =>
+      (reqId?: string): void | Promise<boolean> => {
+        if (!reqId) return
+        return sendMessageRef.current('', {
+          hidden: true,
+          approvalAction: { proposalId: reqId, action },
+        })
+      },
+    [],
+  )
+  const cardApprove = useMemo(() => cardResolve('approve'), [cardResolve])
+  const cardReject = useMemo(() => cardResolve('reject'), [cardResolve])
 
   const createReducerOptions = useCallback(
     (): ChatStreamReducerOptions => ({
@@ -415,7 +419,9 @@ export function useSseChatAdapter(
   )
 
   const sendMessage = useCallback(
-    async (text: string, sendOptions?: InternalSendMessageOptions): Promise<void> => {
+    // Resolves `true` on a clean turn, `false` when the request failed
+    // (surfaced to batch approve-all loops via the card callbacks).
+    async (text: string, sendOptions?: InternalSendMessageOptions): Promise<boolean> => {
       const { hidden, attachments, commandOverride, approvalAction } = sendOptions ?? {}
 
       // URL + body branch — approvalAction routes to the approval-tool
@@ -466,7 +472,20 @@ export function useSseChatAdapter(
           signal: ctrl.signal,
         })
         if (!response.ok) {
-          throw new Error(`Chat request failed: ${response.status}`)
+          // Surface the SERVER's error copy (route-base envelope
+          // `{error, code}`) — a bare "Chat request failed: 409" told
+          // the user nothing when e.g. a batch approval expired; the
+          // server ships real copy ("This approval expired — ...").
+          let serverMessage: string | null = null
+          try {
+            const errBody = (await response.json()) as { error?: unknown }
+            if (typeof errBody?.error === 'string' && errBody.error.length > 0) {
+              serverMessage = errBody.error
+            }
+          } catch {
+            /* non-JSON error body — fall through to the generic copy */
+          }
+          throw new Error(serverMessage ?? `Chat request failed: ${response.status}`)
         }
         const reader = response.body?.getReader()
         if (!reader) throw new Error('No response body')
@@ -496,19 +515,24 @@ export function useSseChatAdapter(
             for (const event of endEvents) applyEvent(event)
           }
         }
+        return true
       } catch (err) {
         // AbortError on user-initiated stop is expected — keep the partial
-        // message, no error row.
-        if ((err as { name?: string })?.name !== 'AbortError' && !ctrl.signal.aborted) {
-          flushDeltas()
-          mutate((r) =>
-            r.failSseTurn(
-              err instanceof Error
-                ? err.message
-                : 'An error occurred while processing your request.',
-            ),
-          )
+        // message, no error row, and DON'T report failure (`true`): the
+        // request may have committed server-side, and a `false` here
+        // would falsely tick a batch row's failure cross.
+        if ((err as { name?: string })?.name === 'AbortError' || ctrl.signal.aborted) {
+          return true
         }
+        flushDeltas()
+        mutate((r) =>
+          r.failSseTurn(
+            err instanceof Error
+              ? err.message
+              : 'An error occurred while processing your request.',
+          ),
+        )
+        return false
       } finally {
         if (abortControllerRef.current === ctrl) {
           abortControllerRef.current = null
@@ -657,9 +681,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 } },
       })