@flamingo-stack/openframe-frontend-core 0.0.577 → 0.0.578-1950.5326.1

package/package.json

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

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

@@ -98,9 +98,9 @@ import type { UnifiedChatState } from './types/unified-chat-state.types';
 import { formatChatAttachmentMarkdownForBubble } from './utils/chat-attachment-markdown';
 import { resolveHrefForRuntime } from './utils/chat-nav-resolution';
 import { chatChipClass } from './utils/chip-styles';
+import { executeNavigation } from './utils/execute-navigation';
 import { resolveIcon } from './utils/icon-library';
 import { computeIsNewTab, newTabAnchorAttrs } from './utils/nav-anchor-props';
-import { handleChatNavClick } from './utils/nav-click-handler';
 import { formatSingularLookupInvocation } from './utils/slash-dispatch-utils';
 import { getSourceIconName } from './utils/source-icons';
 import { resolveSourceRowCTA, sourceRowCtxFromRuntime } from './utils/source-row-cta';
@@ -732,7 +732,14 @@ function SourceChip({
   const buildClickHandler =
     (href: string, path: string | null | undefined, targetPlatform: string | null, isNewTab: boolean) =>
     (e: React.MouseEvent<HTMLAnchorElement>) => {
-      const handled = handleChatNavClick(e, runtime, { href, path, targetPlatform }, router.push);
+      const handled = executeNavigation({
+        event: e,
+        runtime,
+        href,
+        path,
+        targetPlatform,
+        fallbackNavigate: router.push,
+      });
       if (handled && !isNewTab && onClose) onClose();
     };
 

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

@@ -52,5 +52,5 @@ const card = renderChatInlineEntityCard(chatRef, {
 ## Related Files
 
 - [`chat-ref.types.ts`](https://github.com/flamingo-stack/openframe-oss-lib/blob/main/src/types/chat-ref.types.ts) — `ChatRef` shape
-- [`nav-click-handler.ts`](https://github.com/flamingo-stack/openframe-oss-lib/blob/main/src/utils/nav-click-handler.ts) — `handleChatNavClick`
+- [`execute-navigation.ts`](https://github.com/flamingo-stack/openframe-oss-lib/blob/main/src/utils/execute-navigation.ts) — `executeNavigation`
 - [`product-release-card-defaults.ts`](https://github.com/flamingo-stack/openframe-oss-lib/blob/main/src/components/cards/product-release-card-defaults.ts) — Fallback prop builder

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

@@ -83,10 +83,10 @@ import type { BaseProgramItem, ProgramConfig } from '../types/entities/program-t
 import { getStatusColorScheme } from '../utils/agent-status-message';
 import { resolveHrefForRuntime } from '../utils/chat-nav-resolution';
 import { safeHref } from '../utils/compact-card-classes';
+import { executeNavigation } from '../utils/execute-navigation';
 import { clickupTaskUrl } from '../utils/external-app-urls';
 import { computeIsNewTab, buildAnchorProps } from '../utils/nav-anchor-props';
-import { handleChatNavClick } from '../utils/nav-click-handler';
-import { resolveFetchedCardHref, readFetchedCardTitle } from '../utils/resolve-fetched-card-href';
+import { resolveFetchedCardHref, pickFetchedCardHref, readFetchedCardTitle } from '../utils/resolve-fetched-card-href';
 import { getSourceLabel } from '../utils/source-icons';
 import { resolveSourceRowCTA, resolveSourceIcon, sourceRowCtxFromRuntime } from '../utils/source-row-cta';
 import { BlockCard } from './block-card';
@@ -1215,13 +1215,18 @@ interface ChatCardRegistryEntry {
    *  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). Takes precedence over
-   *  the `composeContentUrl` fallback below. */
+   *  the `composeContentUrl` fallback below — but NOT over an explicit
+   *  host `override` for the type (see `pickFetchedCardHref`). */
   fallbackHref?: (item: ChatCardItem) => string | null;
-  /** Opt OUT of the post-fetch `composeContentUrl` fallback (see
+  /** Opt OUT of the post-fetch `composeContentUrl` SYNTHESIS (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. */
+   *  from its default branch and hand the user a 404.
+   *
+   *  It does NOT opt out of the seam itself: an explicit host `override`
+   *  for the type still wins (`pickFetchedCardHref`). That split is the
+   *  point — a host that re-homes a type must be able to say so even when
+   *  the row already carries the content host's own url. */
   noComposedHref?: boolean;
 }
 
@@ -1234,6 +1239,12 @@ interface ChatCardRegistryEntry {
  * (`fallbackHref`), no `<origin>/<type>/<id>` synthesis
  * (`noComposedHref`). Loading shows the skeleton, exactly like every
  * other fetch card.
+ *
+ * NOTE `item.url` is minted by the CONTENT host for its OWN surface, so an
+ * embedder that serves the same rows elsewhere overrides the type in its
+ * `composeContentUrl` config and that wins here — see `pickFetchedCardHref`.
+ * (Observed: hub tickets are `/tickets?ticket=…`, which in the OpenFrame
+ * console resolved against its own unrelated `/tickets` board.)
  */
 function refHydratedEntry(
   docType: string,
@@ -1667,7 +1678,7 @@ function ChatCardNavWrap({
     if (targetEl?.closest?.('button')) return;
     if (!targetEl?.closest?.('a')) return;
 
-    const handled = handleChatNavClick(e, runtime, { href, path, targetPlatform }, router.push);
+    const handled = executeNavigation({ event: e, runtime, href, path, targetPlatform, fallbackNavigate: router.push });
     if (!handled) return;
     // Modifier-clicks fall through (handled=false) without stopPropagation
     // so ancestor telemetry handlers still see the bubble.
@@ -1763,16 +1774,22 @@ export function ChatCardLoader({
   // visit. `safeHref` blocks `javascript:` / `data:` payloads even
   // though the registry callers compose hub-internal strings today.
   //
-  // Two sources, in order:
+  // Two producers, ranked by `pickFetchedCardHref` (which owns the
+  // precedence and its rationale):
   //   1. the registry's per-type `fallbackHref` — an explicit non-content
-  //      destination (marketing campaign → `/admin/...`);
+  //      destination (marketing campaign → `/admin/...`, or a ref-hydrated
+  //      row's own `item.url`);
   //   2. the host's `composeContentUrl` seam via `resolveFetchedCardHref` —
   //      the SAME resolver page cards go through. This is what makes cards
   //      clickable on every transport: the wire ships bare
   //      `[card://type:id]` markers with no metadata, so the ref reaches
   //      us with `url: null` and `resolveSourceRowCTA` has nothing to route.
+  // …except an EXPLICIT host override outranks both: the seam is asked
+  // even for `fallbackHref` / `noComposedHref` types now, and its answer is
+  // taken only when the host actually re-homed the type (never when the
+  // composer merely synthesized one) — the case those two flags guard against.
   const composedHref =
-    fetchEntry?.contentRefType && !resolvedChatRef.url && item && !fetchEntry.fallbackHref && !fetchEntry.noComposedHref
+    fetchEntry?.contentRefType && !resolvedChatRef.url && item
       ? resolveFetchedCardHref({
           contentRefType: fetchEntry.contentRefType,
           id: resolvedChatRef.id,
@@ -1780,19 +1797,22 @@ export function ChatCardLoader({
           composeContentUrl: runtime.composeContentUrl,
         })
       : null;
-  const hrefResolvedChatRef: ChatRef =
-    fetchEntry && !resolvedChatRef.url && item && fetchEntry.fallbackHref
-      ? {
-          ...resolvedChatRef,
-          url: safeHref(fetchEntry.fallbackHref(item)),
-        }
-      : composedHref
-        ? {
-            ...resolvedChatRef,
-            url: safeHref(composedHref.href),
-            targetPlatform: composedHref.targetPlatform ?? resolvedChatRef.targetPlatform ?? null,
-          }
-        : resolvedChatRef;
+  const hrefChoice =
+    fetchEntry && !resolvedChatRef.url && item
+      ? pickFetchedCardHref({
+          composed: composedHref,
+          itemHref: fetchEntry.fallbackHref?.(item) ?? null,
+          allowComposed: !fetchEntry.noComposedHref,
+        })
+      : null;
+  const hrefResolvedChatRef: ChatRef = hrefChoice
+    ? {
+        ...resolvedChatRef,
+        url: safeHref(hrefChoice.href),
+        // The `item` branch carries no platform of its own — keep the ref's.
+        targetPlatform: hrefChoice.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

package/src/components/chat/hooks/.use-unified-chat.md

@@ -26,7 +26,11 @@ Hook input shape.
 ### `useUnifiedChat(options)`
 Main hook. Returns a stable `UnifiedChatState` composed of:
 - **Active adapter state** — messages, streaming phase, token usage, connection
-- **Stable action callbacks** — `sendMessage`, `stopMessage`, `clearMessages`, `discussRef`, `displayRef`
+- **Stable action callbacks** — `sendMessage`, `stopMessage`, `clearMessages`, `discussRef`, and
+  `displayRef` **only when the active adapter has one**. `displayRef` is optional on the state and
+  the NATS/Mingo adapters omit it, because consumers gate the card menu's "Display" row on the
+  callback being there; forwarding an always-truthy wrapper around a missing method would advertise
+  a display path that isn't there and throw on click.
 - **Dialog management** — `selectDialog`, `startNewDialog`, `deleteDialog`, `renameDialog`, `archiveDialog`, `loadMoreDialogs`, `setDialogScope`, `reloadDialogs`, `loadMoreMessages`
 - **Approvals** — `approveRequest`, `rejectRequest`
 

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

@@ -1093,11 +1093,10 @@ export function useNatsChatAdapter(
     },
     [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 */
-  }, []);
+  // No `displayRef` here: it dispatches a `/… display "<x>"` slash command and
+  // the agent transport has no slash-command registry. OMITTED rather than
+  // stubbed — the card menu gates on the callback's presence, so a stub costs
+  // the row "Ask Mingo", which does work in Mingo mode.
 
   // ─── Return shape ─────────────────────────────────────────────────────────
 
@@ -1115,7 +1114,6 @@ export function useNatsChatAdapter(
       stopMessage,
       clearMessages,
       discussRef,
-      displayRef,
       // Model badge + token usage for the composer's `<ModelDisplay>`.
       // Model: live `metadata` frame → config baseline (host AI-config).
       // Tokens: live `token_usage` frame / dialog snapshot (`dialogTokenUsage`).
@@ -1160,7 +1158,6 @@ export function useNatsChatAdapter(
       stopMessage,
       clearMessages,
       discussRef,
-      displayRef,
       dialogs,
       dialogId,
       selectDialog,

package/src/components/chat/hooks/use-unified-chat.ts

@@ -153,10 +153,16 @@ export function useUnifiedChat(options: UseUnifiedChatOptions): UnifiedChatState
     (ref: Parameters<UnifiedChatState['discussRef']>[0]) => activeStateRef.current.discussRef(ref),
     [],
   );
-  const displayRef = useCallback(
-    (ref: Parameters<UnifiedChatState['displayRef']>[0]) => activeStateRef.current.displayRef(ref),
+  // `displayRef` is OPTIONAL on the state and consumers gate the "Display"
+  // affordance on its presence, so the forward has to be able to be absent
+  // too: an always-truthy wrapper around a missing method advertises a
+  // display path that isn't there and throws when the menu row is clicked.
+  // Only the flag flips identity — the wrapper itself stays stable.
+  const displayRefForward = useCallback(
+    (ref: Parameters<NonNullable<UnifiedChatState['displayRef']>>[0]) => activeStateRef.current.displayRef?.(ref),
     [],
   );
+  const displayRef = activeState.displayRef ? displayRefForward : undefined;
 
   // Dialog-management forwards — one thin wrapper per action so the
   // returned identity stays stable as long as the active adapter's

package/src/components/chat/nav-link-anchor-via-runtime.tsx

@@ -27,8 +27,8 @@ import { useRequiredChatRuntime } from '../../contexts/chat-runtime-context';
 import { useRouter } from '../../embed-shims/next-navigation';
 import { useChatPanel } from './chat-panel-context';
 import { resolveHrefForRuntime } from './utils/chat-nav-resolution';
+import { executeNavigation } from './utils/execute-navigation';
 import { computeIsNewTab, newTabAnchorAttrs } from './utils/nav-anchor-props';
-import { handleChatNavClick } from './utils/nav-click-handler';
 
 export interface NavLinkAnchorViaRuntimeProps {
   href: string;
@@ -54,16 +54,14 @@ export function NavLinkAnchorViaRuntime({
   const isNewTab = computeIsNewTab(runtime, resolvedHref, targetPlatform ?? null);
 
   const onClick = (e: MouseEvent<HTMLAnchorElement>) => {
-    const handled = handleChatNavClick(
-      e,
+    const handled = executeNavigation({
+      event: e,
       runtime,
-      {
-        href: resolvedHref,
-        path,
-        targetPlatform,
-      },
-      router.push,
-    );
+      href: resolvedHref,
+      path,
+      targetPlatform,
+      fallbackNavigate: router.push,
+    });
     if (handled && !isNewTab && panel?.closeChat) panel.closeChat();
   };
   return (

package/src/components/chat/types/.unified-chat-state.types.md

@@ -51,6 +51,7 @@ function MyChatShell({ chat }: { chat: UnifiedChatState }) {
 | `currentProvider` / `currentModelLabel` | ✅ Populated | `null` |
 | `currentUsageBreakdown` | ✅ After trailing frame | `null` |
 | `DialogTokenUsage` (separate) | `null` | ✅ From GraphQL |
-| `discussRef` / `displayRef` | ✅ Active | no-op |
+| `discussRef` | ✅ Active | ✅ Active (prompt carries the reference as text) |
+| `displayRef` | ✅ Active | **omitted** (optional — consumers fall back to "Ask Mingo") |
 
 > **Source:** [`unified-chat-state.types.ts`](https://github.com/flamingo-stack/openframe-oss-lib/blob/main/unified-chat-state.types.ts)

package/src/components/chat/types/unified-chat-state.types.ts

@@ -286,9 +286,16 @@ export interface UnifiedChatState {
 
   /**
    * Trigger the chat's "Display this row" affordance — same as `discussRef`
-   * but for read-only card display rather than a question. Guide-mode only.
+   * but for read-only card display rather than a question. Guide-mode only:
+   * it dispatches a `/<cmd> display "<x>"` slash command, and only the SSE
+   * transport has a slash-command registry.
+   *
+   * OPTIONAL, and OMITTED — not stubbed — by adapters that have no display
+   * path. Consumers gate the affordance on its presence (`entity-cards`'
+   * dispatcher falls back to "Ask Mingo" when it is absent), so a no-op stub
+   * renders a dead "Display" row where the action that works belongs.
    */
-  displayRef: (ref: ChatRef) => void;
+  displayRef?: (ref: ChatRef) => void;
 
   // ─── Per-turn LLM metadata (Guide/SSE only) ───────────────────────────────
   /**

package/src/components/chat/utils/__tests__/execute-navigation.test.ts

@@ -0,0 +1,190 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ChatRuntime } from '../../../../contexts/chat-runtime-context';
+import { stripSameOriginToPath } from '../chat-nav-resolution';
+import { decideNewTab } from '../decide-new-tab';
+import { executeNavigation } from '../execute-navigation';
+
+/**
+ * The click path had no tests, which is why every host bug it produced was
+ * answered with another defensive layer instead of a case here. These pin the
+ * two decisions a click makes — WHICH TAB, and WHO PERFORMS IT.
+ */
+
+/** jsdom's own origin — the strip is a comparison against it, so it must be real. */
+const ORIGIN = new URL(window.location.href).origin;
+
+function runtimeWith(navigation: Partial<ChatRuntime['navigation']> = {}): ChatRuntime {
+  return {
+    endpoints: { chatStreamUrl: `${ORIGIN}/chat` },
+    navigation: { mode: 'host', ...navigation },
+    source: 'openframe',
+  } as ChatRuntime;
+}
+
+function primaryClick() {
+  return { preventDefault: vi.fn(), button: 0 };
+}
+
+beforeEach(() => {
+  window.history.replaceState(null, '', '/dashboard');
+});
+
+describe('stripSameOriginToPath', () => {
+  it('reduces a same-origin absolute URL to a router-pushable path', () => {
+    expect(stripSameOriginToPath(`${ORIGIN}/help-center/guides?slug=a#top`)).toBe('/help-center/guides?slug=a#top');
+  });
+
+  it('strips a CROSS-origin URL too — the caller owns that decision', () => {
+    // Deliberate: the hub is one app across several origins and relies on this to
+    // keep an absolute in-app href on the host it is running (preview, localhost).
+    // The "is this foreign?" question belongs to `runNavigation`, tested below.
+    expect(stripSameOriginToPath('https://www.flamingo.run/webinars/x')).toBe('/webinars/x');
+  });
+
+  it('passes relative hrefs through untouched', () => {
+    expect(stripSameOriginToPath('/devices/details?id=1')).toBe('/devices/details?id=1');
+  });
+});
+
+describe('decideNewTab', () => {
+  it('keeps a relative href in the same tab', () => {
+    expect(decideNewTab({ href: '/help-center/guides', currentSource: 'openframe' })).toBe(false);
+  });
+
+  it('sends a cross-origin href to a new tab', () => {
+    expect(decideNewTab({ href: 'https://www.flamingo.run/blog/x', currentSource: 'openframe' })).toBe(true);
+  });
+
+  it('lets a matching targetPlatform beat the origin compare — same tab, cross-origin', () => {
+    // The trap openframe hit: the RAG tags every row `openframe`, so a hub URL
+    // matched `source` and went same-tab. Pinned because it is surprising, and
+    // because hosts that do NOT host that content must pass `targetPlatform: null`.
+    expect(
+      decideNewTab({
+        href: 'https://www.flamingo.run/webinars/x',
+        targetPlatform: 'openframe',
+        currentSource: 'openframe',
+      }),
+    ).toBe(false);
+  });
+
+  it('forces a new tab in embed mode regardless of origin', () => {
+    expect(decideNewTab({ href: '/anything', currentSource: 'openframe', runtimeMode: 'embed' })).toBe(true);
+  });
+});
+
+describe('executeNavigation', () => {
+  it('hands a same-tab click to the host navigate callback', () => {
+    const navigate = vi.fn().mockReturnValue(true);
+    const fallbackNavigate = vi.fn();
+    const event = primaryClick();
+
+    const handled = executeNavigation({
+      event,
+      runtime: runtimeWith({ navigate }),
+      href: '/help-center/guides',
+      fallbackNavigate,
+    });
+
+    expect(handled).toBe(true);
+    expect(event.preventDefault).toHaveBeenCalled();
+    expect(navigate).toHaveBeenCalledWith(expect.objectContaining({ href: '/help-center/guides' }));
+    expect(fallbackNavigate).not.toHaveBeenCalled();
+  });
+
+  it('falls back to the host router when navigate declines', () => {
+    const fallbackNavigate = vi.fn();
+
+    executeNavigation({
+      event: primaryClick(),
+      runtime: runtimeWith({ navigate: () => false }),
+      href: '/help-center/guides',
+      fallbackNavigate,
+    });
+
+    expect(fallbackNavigate).toHaveBeenCalledWith('/help-center/guides');
+  });
+
+  it('opens an absolute SAME-origin href in a new tab', () => {
+    // Not a defect: `isCrossOriginUrl` is textual on purpose (SSR-deterministic,
+    // see its tests), so "in-app links stay relative" is a real host obligation.
+    // Pinned because hosts keep rediscovering it by absolutizing an in-app href
+    // and getting a redundant new tab.
+    const openExternal = vi.fn();
+    const fallbackNavigate = vi.fn();
+
+    executeNavigation({
+      event: primaryClick(),
+      runtime: runtimeWith({ openExternal }),
+      href: `${ORIGIN}/help-center/guides`,
+      fallbackNavigate,
+    });
+
+    expect(openExternal).toHaveBeenCalledWith(`${ORIGIN}/help-center/guides`);
+    expect(fallbackNavigate).not.toHaveBeenCalled();
+  });
+
+  it('still strips an absolute SAME-origin href down to a path', () => {
+    // The hub's soft-RSC-nav case: one app, several origins, absolute in-app
+    // href routed same-tab. It must stay a soft nav, not a full page load.
+    const fallbackNavigate = vi.fn();
+
+    executeNavigation({
+      event: primaryClick(),
+      runtime: runtimeWith({ navigate: () => false, decideNewTab: () => false }),
+      href: `${ORIGIN}/releases/v1?x=1#top`,
+      fallbackNavigate,
+    });
+
+    expect(fallbackNavigate).toHaveBeenCalledWith('/releases/v1?x=1#top');
+  });
+
+  it('passes a cross-origin href to the router WHOLE', () => {
+    // Regression: it used to arrive origin-stripped and 404 locally.
+    const fallbackNavigate = vi.fn();
+
+    executeNavigation({
+      event: primaryClick(),
+      runtime: runtimeWith({ navigate: () => false, decideNewTab: () => false }),
+      href: 'https://www.flamingo.run/webinars/x',
+      fallbackNavigate,
+    });
+
+    expect(fallbackNavigate).toHaveBeenCalledWith('https://www.flamingo.run/webinars/x');
+  });
+
+  it('routes a new-tab decision through openExternal', () => {
+    const openExternal = vi.fn();
+    const fallbackNavigate = vi.fn();
+
+    executeNavigation({
+      event: primaryClick(),
+      runtime: runtimeWith({ openExternal, decideNewTab: () => true }),
+      href: 'https://www.flamingo.run/blog/x',
+      fallbackNavigate,
+    });
+
+    expect(openExternal).toHaveBeenCalledWith('https://www.flamingo.run/blog/x');
+    expect(fallbackNavigate).not.toHaveBeenCalled();
+  });
+
+  it('leaves modifier clicks to the browser', () => {
+    const navigate = vi.fn();
+    const event = { preventDefault: vi.fn(), button: 0, metaKey: true };
+
+    const handled = executeNavigation({ event, runtime: runtimeWith({ navigate }), href: '/x' });
+
+    expect(handled).toBe(false);
+    expect(event.preventDefault).not.toHaveBeenCalled();
+    expect(navigate).not.toHaveBeenCalled();
+  });
+
+  it('reports an empty href as handled without navigating anywhere', () => {
+    const fallbackNavigate = vi.fn();
+    const event = primaryClick();
+
+    expect(executeNavigation({ event, runtime: runtimeWith(), href: '', fallbackNavigate })).toBe(true);
+    expect(event.preventDefault).toHaveBeenCalled();
+    expect(fallbackNavigate).not.toHaveBeenCalled();
+  });
+});

package/src/components/chat/utils/__tests__/resolve-fetched-card-href.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { makeComposeContentUrl } from '../../../../utils/content-href';
-import { resolveFetchedCardHref } from '../resolve-fetched-card-href';
+import { pickFetchedCardHref, resolveFetchedCardHref } from '../resolve-fetched-card-href';
 
 const HUB = 'https://www.flamingo.run';
 
@@ -34,7 +34,7 @@ describe('resolveFetchedCardHref — Mingo cards with no ref metadata', () => {
         item: { id: 'db-uuid-9', title: 'Deep Google Workspace tenant management' },
         composeContentUrl: compose,
       }),
-    ).toEqual({ href: '/help-center/roadmap?search=86ad3qvv5', targetPlatform: null });
+    ).toEqual({ href: '/help-center/roadmap?search=86ad3qvv5', targetPlatform: null, hostOverride: true });
   });
 
   it('hosted type uses the fetched row slug for its in-app detail route', () => {
@@ -152,3 +152,76 @@ describe('makeComposeContentUrl — the new `slug` hint', () => {
     });
   });
 });
+
+describe('pickFetchedCardHref — which producer owns a fetched card destination', () => {
+  const composedPlain = { href: `${HUB}/tickets/47979601418`, targetPlatform: null };
+  const composedOverride = {
+    href: '/help-center/tickets?ticket=479&search=479#ticket-479',
+    targetPlatform: null,
+    hostOverride: true,
+  };
+
+  it('an explicit host override beats the fetched row url', () => {
+    // The regression: `hubspot_ticket_self` hydrates from the hub, whose row
+    // carries `/tickets?ticket=…` — a path the OpenFrame console also owns, for
+    // an unrelated ticket board. The host re-homes the type; that has to win.
+    expect(
+      pickFetchedCardHref({
+        composed: composedOverride,
+        itemHref: '/tickets?ticket=479&search=479#ticket-479',
+        allowComposed: false,
+      }),
+    ).toEqual({
+      source: 'hostOverride',
+      href: '/help-center/tickets?ticket=479&search=479#ticket-479',
+      targetPlatform: null,
+    });
+  });
+
+  it('the row url still beats a merely SYNTHESIZED href — what noComposedHref guards', () => {
+    expect(
+      pickFetchedCardHref({ composed: composedPlain, itemHref: '/tickets?ticket=479', allowComposed: false }),
+    ).toEqual({ source: 'item', href: '/tickets?ticket=479' });
+    // …and even when synthesis is allowed, a row that knows its own url wins.
+    expect(
+      pickFetchedCardHref({ composed: composedPlain, itemHref: '/tickets?ticket=479', allowComposed: true }),
+    ).toEqual({ source: 'item', href: '/tickets?ticket=479' });
+  });
+
+  it('falls through to the composed href only when the registry allows synthesis', () => {
+    expect(pickFetchedCardHref({ composed: composedPlain, itemHref: null, allowComposed: true })).toEqual({
+      source: 'composed',
+      href: `${HUB}/tickets/47979601418`,
+      targetPlatform: null,
+    });
+    expect(pickFetchedCardHref({ composed: composedPlain, itemHref: null, allowComposed: false })).toBeNull();
+  });
+
+  it('nothing to link to → null (card renders unlinked)', () => {
+    expect(pickFetchedCardHref({ composed: null, itemHref: null, allowComposed: true })).toBeNull();
+  });
+
+  it('an override with no host seam wired cannot appear — null composed, row url stands', () => {
+    expect(pickFetchedCardHref({ composed: null, itemHref: '/tickets?ticket=479', allowComposed: true })).toEqual({
+      source: 'item',
+      href: '/tickets?ticket=479',
+    });
+  });
+});
+
+describe('makeComposeContentUrl — hostOverride flag', () => {
+  it('marks ONLY the explicit overrides branch', () => {
+    expect(compose({ type: 'roadmap_item', identifier: 'task-1' })).toEqual({
+      href: '/help-center/roadmap?search=task-1',
+      targetPlatform: null,
+      hostOverride: true,
+    });
+    // hosted, verbatim-externalUrl and origin-synthesis branches stay unflagged,
+    // so a fetched row's own url keeps beating them.
+    expect(compose({ type: 'product_release', identifier: 'rel-1', slug: 'v1' }).hostOverride).toBeUndefined();
+    expect(
+      compose({ type: 'blog_post', identifier: 'b-1', externalUrl: `${HUB}/blog/x` }).hostOverride,
+    ).toBeUndefined();
+    expect(compose({ type: 'blog_post', identifier: 'b-1' }).hostOverride).toBeUndefined();
+  });
+});

package/src/components/chat/utils/chat-nav-resolution.ts

@@ -32,9 +32,15 @@ export function isModifierClick(e: {
   return e.button !== 0 || !!e.metaKey || !!e.ctrlKey || !!e.shiftKey || !!e.altKey;
 }
 
-/** Strip the origin from a same-origin absolute URL, returning a relative
- *  path the host's router will treat as in-app navigation. Pass-through
- *  for already-relative URLs and for cross-origin URLs. */
+/** Strip the origin from an absolute URL, returning a relative path the host's
+ *  router will treat as in-app navigation. Already-relative URLs pass through.
+ *
+ *  Strips the origin off ANY absolute URL, cross-origin included — the caller
+ *  decides. The hub relies on that: its platforms are one Next app on several
+ *  origins, so an absolute `https://openmsp.ai/x` opened same-tab must stay on
+ *  whatever host is running (prod, a preview deploy, or localhost). Callers that
+ *  can be handed a genuinely FOREIGN href must check the origin first, or they
+ *  push a path that 404s on their own — see `runNavigation`. */
 export function stripSameOriginToPath(href: string): string {
   if (!href.startsWith('http')) return href;
   try {

package/src/components/chat/utils/execute-navigation.ts

@@ -31,7 +31,12 @@
 import type { ChatRuntime } from '../../../contexts/chat-runtime-context';
 import { navigateSamePageHash, STICKY_HEADER_OFFSET_PX } from '../../../utils/same-page-hash-nav';
 import { NEW_TAB_FEATURES, stripSameOriginToPath } from './chat-nav-resolution';
-import { computeIsNewTab } from './nav-anchor-props';
+import { computeIsNewTab, isSameOriginAbsoluteHref } from './nav-anchor-props';
+
+/** Absolute `http(s)` URL pointing at an origin that is not ours. */
+function isForeignOriginHref(href: string): boolean {
+  return /^https?:\/\//i.test(href) && !isSameOriginAbsoluteHref(href);
+}
 
 /** Minimal mouse-event surface — structural so chip buttons / tiles can call it
  *  without casting `React.MouseEvent`. */
@@ -78,7 +83,12 @@ function runNavigation(
     else window.open(href, '_blank', NEW_TAB_FEATURES);
     return;
   }
-  const target = stripSameOriginToPath(href);
+  // A FOREIGN href that the host's `decideNewTab` routed same-tab must reach the
+  // router whole: stripping its origin pushes `/webinars/x` onto OUR origin and
+  // 404s. Same-origin absolutes still get stripped, so an in-app soft nav stays
+  // one. (`stripSameOriginToPath` itself strips unconditionally on purpose — the
+  // hub is one app across several origins and depends on that.)
+  const target = isForeignOriginHref(href) ? href : stripSameOriginToPath(href);
   // Same-page hash target (e.g. a chat card deep-linking to `/faqs#faq-item-49`):
   // route through the UNIFIED same-page-hash primitive FIRST. A host router /
   // `router.push` performs `pushState`, which the HTML spec says does NOT fire a
@@ -139,3 +149,23 @@ export function executeNavigationImperative({
 }: ExecuteNavigationImperativeArgs): void {
   runNavigation(runtime, href, undefined, targetPlatform, fallbackNavigate);
 }
+
+/**
+ * @deprecated Call {@link executeNavigation} directly. Kept only so external
+ * embedders' imports keep resolving; no lib code path goes through it.
+ */
+export function handleChatNavClick(
+  event: NavClickEvent,
+  runtime: ChatRuntime | null | undefined,
+  { href, path, targetPlatform }: ChatNavClickInput,
+  fallbackNavigate?: (path: string) => void,
+): boolean {
+  return executeNavigation({ event, runtime, href, path, targetPlatform, fallbackNavigate });
+}
+
+/** @deprecated Argument shape of the deprecated {@link handleChatNavClick}. */
+export interface ChatNavClickInput {
+  href: string;
+  path?: string | null;
+  targetPlatform?: string | null;
+}