@nextclaw/ui 0.15.20 → 0.15.22

package/src/features/chat/managers/__tests__/chat-completion-notification.manager.test.ts

@@ -0,0 +1,177 @@
+import {
+  NCP_INTERNAL_VISIBILITY_METADATA_KEY,
+  NcpEventType,
+  type NcpEndpointEvent,
+  type NcpMessage,
+} from "@nextclaw/ncp";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ChatCompletionNotificationManager } from "@/features/chat/managers/chat-completion-notification.manager";
+import { buildSessionPath } from "@/features/chat/features/session/utils/chat-session-route.utils";
+import { useChatQueryStore } from "@/features/chat/stores/ncp-chat-query.store";
+
+const mocks = vi.hoisted(() => ({
+  eventHandler: null as ((event: NcpEndpointEvent) => void) | null,
+  on: vi.fn(),
+  unsubscribe: vi.fn(),
+}));
+
+vi.mock("@/shared/lib/api", () => ({
+  nextclawClient: {
+    eventBus: {
+      on: mocks.on,
+    },
+  },
+}));
+
+function createMessage(overrides: Partial<NcpMessage> = {}): NcpMessage {
+  return {
+    id: "assistant-message-1",
+    sessionId: "session-background",
+    role: "assistant",
+    status: "final",
+    timestamp: "2026-08-05T10:00:00.000Z",
+    parts: [{ type: "text", text: "  The requested research is complete.  " }],
+    ...overrides,
+  };
+}
+
+function createCompletedEvent(message = createMessage()): NcpEndpointEvent {
+  return {
+    type: NcpEventType.MessageCompleted,
+    payload: {
+      sessionId: message.sessionId,
+      message,
+    },
+  };
+}
+
+function emit(event: NcpEndpointEvent): void {
+  if (!mocks.eventHandler) {
+    throw new Error("Notification manager has not subscribed");
+  }
+  mocks.eventHandler(event);
+}
+
+describe("ChatCompletionNotificationManager", () => {
+  const show = vi.fn();
+  let manager: ChatCompletionNotificationManager;
+
+  beforeEach(() => {
+    mocks.eventHandler = null;
+    mocks.on.mockReset();
+    mocks.unsubscribe.mockReset();
+    mocks.on.mockImplementation((_key, handler: (event: NcpEndpointEvent) => void) => {
+      mocks.eventHandler = handler;
+      return mocks.unsubscribe;
+    });
+    show.mockReset();
+    useChatQueryStore.setState({ snapshot: {} });
+    manager = new ChatCompletionNotificationManager({ show });
+  });
+
+  afterEach(() => {
+    manager.stop();
+  });
+
+  it("maps a background assistant final reply to a navigable global notification", () => {
+    useChatQueryStore.setState({
+      snapshot: {
+        sessionsQuery: {
+          data: {
+            sessions: [{
+              sessionId: "session-background",
+              messageCount: 2,
+              updatedAt: "2026-08-05T10:00:00.000Z",
+              metadata: { label: "Quarterly research" },
+            }],
+            total: 1,
+          },
+        } as never,
+      },
+    });
+    manager.start();
+    emit(createCompletedEvent());
+
+    expect(show).toHaveBeenCalledWith({
+      id: "chat-reply:assistant-message-1",
+      title: "Quarterly research",
+      description: "The requested research is complete.",
+      href: buildSessionPath("session-background"),
+      ariaLabel: "Open the new reply in Quarterly research",
+    });
+  });
+
+  it("suppresses messages completed in the active session, including later replays", () => {
+    manager.start();
+    manager.syncActiveSession("session-background");
+    emit(createCompletedEvent());
+    expect(show).not.toHaveBeenCalled();
+
+    manager.syncActiveSession(null);
+    emit(createCompletedEvent());
+    expect(show).not.toHaveBeenCalled();
+
+    const nextMessage = createMessage({ id: "assistant-message-2" });
+    emit(createCompletedEvent(nextMessage));
+    emit(createCompletedEvent(nextMessage));
+    expect(show).toHaveBeenCalledOnce();
+  });
+
+  it("ignores non-final, non-assistant, hidden, and unrelated events", () => {
+    manager.start();
+    emit(createCompletedEvent(createMessage({ status: "streaming" })));
+    emit(createCompletedEvent(createMessage({ role: "service" })));
+    emit(createCompletedEvent(createMessage({
+      metadata: { [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden" },
+    })));
+    emit({
+      type: NcpEventType.RunFinished,
+      payload: { sessionId: "session-background" },
+    });
+
+    expect(show).not.toHaveBeenCalled();
+  });
+
+  it("uses localized fallbacks when the session and reply have no display text", () => {
+    manager.start();
+    emit(createCompletedEvent(createMessage({ parts: [] })));
+
+    expect(show).toHaveBeenCalledWith(expect.objectContaining({
+      title: "New reply",
+      description: "A reply is ready. Open the session to view it.",
+    }));
+  });
+
+  it("projects markdown replies into a readable plain-text preview", () => {
+    manager.start();
+    emit(createCompletedEvent(createMessage({
+      parts: [{
+        type: "text",
+        text: [
+          "# Release **complete**",
+          "",
+          "- [x] Open the [report](https://example.com/report)",
+          "> Review `details` and ~~obsolete notes~~",
+          "",
+          "```sh",
+          "pnpm test",
+          "```",
+        ].join("\n"),
+      }],
+    })));
+
+    expect(show).toHaveBeenCalledWith(expect.objectContaining({
+      description: "Release complete Open the report Review details and obsolete notes pnpm test",
+    }));
+  });
+
+  it("owns an idempotent realtime subscription lifecycle", () => {
+    manager.start();
+    manager.start();
+    expect(mocks.on).toHaveBeenCalledOnce();
+
+    manager.stop();
+    manager.stop();
+    expect(mocks.unsubscribe).toHaveBeenCalledOnce();
+  });
+});

package/src/features/chat/managers/__tests__/chat-session-list.manager.test.ts

@@ -70,6 +70,18 @@ function resetChatSessionListManagerState() {
 describe("ChatSessionListManager draft and selection flow", () => {
   beforeEach(resetChatSessionListManagerState);
 
+  it("clears the route-derived session selection outside session routes", () => {
+    const manager = new ChatSessionListManager(
+      {} as ConstructorParameters<typeof ChatSessionListManager>[0],
+    );
+
+    manager.syncRouteSessionSelection(null);
+
+    expect(
+      useChatSessionListStore.getState().snapshot.selectedSessionKey,
+    ).toBeNull();
+  });
+
   it("applies the requested session type when creating a session", () => {
     const uiManager = {
       goToChatRoot: vi.fn(),
@@ -93,7 +105,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
     });
     expect(
       useChatSessionListStore.getState().snapshot.selectedSessionKey,
-    ).toBeNull();
+    ).toBe("session-1");
     expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
     expect(
       useChatThreadStore.getState().snapshot.hasSubmittedDraftMessage,
@@ -126,7 +138,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
     );
     expect(
       useChatSessionListStore.getState().snapshot.selectedSessionKey,
-    ).toBeNull();
+    ).toBe("session-1");
     expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
     expect(
       useChatThreadStore.getState().snapshot.hasSubmittedDraftMessage,
@@ -198,7 +210,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
 
     expect(
       useChatSessionListStore.getState().snapshot.selectedSessionKey,
-    ).toBeNull();
+    ).toBe("session-1");
     expect(uiManager.navigateTo).toHaveBeenCalledWith(
       "/chat/draft",
       expect.any(Object),

package/src/features/chat/managers/__tests__/chat-thread.manager.test.ts

@@ -836,7 +836,7 @@ describe('ChatThreadManager visible workspace selection', () => {
 });
 
 describe('ChatThreadManager deletion', () => {
-  it('clears the selected thread state after deleting the current session', async () => {
+  it('clears thread state while leaving route-derived selection to navigation', async () => {
     const removeQueries = vi.spyOn(appQueryClient, 'removeQueries').mockImplementation(async () => undefined);
     const uiManager = {
       goToSession: vi.fn(),
@@ -844,13 +844,7 @@ describe('ChatThreadManager deletion', () => {
       goToProviders: vi.fn(),
       confirm: vi.fn(async () => true),
     } as unknown as ConstructorParameters<typeof ChatThreadManager>[0];
-    const sessionListManager = {
-      setSelectedSessionKey: vi.fn((value: string | null) => {
-        useChatSessionListStore.getState().setSnapshot({
-          selectedSessionKey: value,
-        });
-      }),
-    } as unknown as ConstructorParameters<typeof ChatThreadManager>[1];
+    const sessionListManager = {} as ConstructorParameters<typeof ChatThreadManager>[1];
     const manager = new ChatThreadManager(
       uiManager,
       sessionListManager,
@@ -858,8 +852,7 @@ describe('ChatThreadManager deletion', () => {
 
     await manager.deleteSession();
 
-    expect(sessionListManager.setSelectedSessionKey).toHaveBeenCalledWith(null);
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('parent-session-1');
     expect(useChatThreadStore.getState().snapshot).toMatchObject({
       sessionKey: null,
       canDeleteSession: false,

package/src/features/chat/managers/chat-completion-notification.manager.ts

@@ -0,0 +1,146 @@
+import {
+  isHiddenNcpMessage,
+  NcpEventType,
+  type NcpEndpointEvent,
+  type NcpMessage,
+} from "@nextclaw/ncp";
+import { eventKeys } from "@nextclaw/shared";
+import type { AppNotificationManager } from "@/features/notifications";
+import { buildSessionPath } from "@/features/chat/features/session/utils/chat-session-route.utils";
+import { sessionDisplayName } from "@/features/chat/features/session/utils/chat-session-display.utils";
+import { adaptNcpSessionSummary } from "@/features/chat/features/session/utils/ncp-session-adapter.utils";
+import { useChatQueryStore } from "@/features/chat/stores/ncp-chat-query.store";
+import { nextclawClient } from "@/shared/lib/api";
+import { t } from "@/shared/lib/i18n";
+
+const NOTIFICATION_PREVIEW_MAX_CHARACTERS = 120;
+const NOTIFIED_MESSAGE_HISTORY_LIMIT = 200;
+
+function buildNotificationPreview(value: string): string {
+  const normalized = value
+    .replace(/\r\n?/gu, "\n")
+    .replace(/^[ \t]*\[[^\]]+\]:\s+\S+.*$/gmu, " ")
+    .replace(/^[ \t]*(?:`{3,}|~{3,})[^\n]*$/gmu, " ")
+    .replace(/^[ \t]*\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?[ \t]*$/gmu, " ")
+    .replace(/^[ \t]*(?:[-*_][ \t]*){3,}$/gmu, " ")
+    .replace(/!\[([^\]]*)\]\([^\n)]+\)/gu, "$1")
+    .replace(/\[([^\]]+)\]\([^\n)]+\)/gu, "$1")
+    .replace(/\[([^\]]+)\]\[[^\]]*\]/gu, "$1")
+    .replace(/<(https?:\/\/[^>\s]+)>/gu, "$1")
+    .replace(/<[^>]+>/gu, " ")
+    .replace(/^[ \t]{0,3}#{1,6}[ \t]+/gmu, "")
+    .replace(/^[ \t]*>+[ \t]?/gmu, "")
+    .replace(/^[ \t]*(?:[-+*]|\d+[.)])[ \t]+/gmu, "")
+    .replace(/^[ \t]*\[(?: |x|X)\][ \t]*/gmu, "")
+    .replace(/(`+)([^`]*?)\1/gu, "$2")
+    .replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/gu, "$2")
+    .replace(/~~(?=\S)([\s\S]*?\S)~~/gu, "$1")
+    .replace(/\*(?=\S)([^*\n]*?\S)\*/gu, "$1")
+    .replace(/\\([\\`*{}[\]()#+.!_>-])/gu, "$1")
+    .replace(/^[ \t]*\|(.+)\|[ \t]*$/gmu, (_match, row: string) =>
+      row.split("|").map((cell) => cell.trim()).filter(Boolean).join(" "),
+    )
+    .replace(/\s+/gu, " ")
+    .trim();
+  const characters = Array.from(normalized);
+  if (characters.length <= NOTIFICATION_PREVIEW_MAX_CHARACTERS) {
+    return normalized;
+  }
+  return `${characters.slice(0, NOTIFICATION_PREVIEW_MAX_CHARACTERS - 1).join("")}…`;
+}
+
+function readAssistantReplyPreview(message: NcpMessage): string {
+  return buildNotificationPreview(
+    message.parts
+      .filter((part) => part.type === "text" || part.type === "rich-text")
+      .map((part) => part.text)
+      .join(" "),
+  );
+}
+
+export class ChatCompletionNotificationManager {
+  private readonly cleanups: Array<() => void> = [];
+  private readonly handledMessageIds = new Set<string>();
+  private activeSessionId: string | null = null;
+  private started = false;
+
+  constructor(
+    private readonly notificationManager: Pick<AppNotificationManager, "show">,
+  ) {}
+
+  start = (): void => {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    this.cleanups.push(
+      nextclawClient.eventBus.on(eventKeys.ncpEvent, this.handleNcpEvent),
+    );
+  };
+
+  stop = (): void => {
+    if (!this.started) {
+      return;
+    }
+    this.started = false;
+    while (this.cleanups.length > 0) {
+      this.cleanups.pop()?.();
+    }
+  };
+
+  syncActiveSession = (sessionId: string | null): void => {
+    this.activeSessionId = sessionId?.trim() || null;
+  };
+
+  private readonly handleNcpEvent = (event: NcpEndpointEvent): void => {
+    if (event.type !== NcpEventType.MessageCompleted) {
+      return;
+    }
+
+    const { message } = event.payload;
+    const sessionId = event.payload.sessionId.trim();
+    if (
+      !sessionId ||
+      this.handledMessageIds.has(message.id) ||
+      message.role !== "assistant" ||
+      message.status !== "final" ||
+      isHiddenNcpMessage(message)
+    ) {
+      return;
+    }
+    this.rememberHandledMessage(message.id);
+    if (sessionId === this.activeSessionId) {
+      return;
+    }
+
+    const title = this.resolveSessionTitle(sessionId);
+    const preview = readAssistantReplyPreview(message);
+    this.notificationManager.show({
+      id: `chat-reply:${message.id}`,
+      title,
+      description: preview || t("chatBackgroundReplyFallbackPreview"),
+      href: buildSessionPath(sessionId),
+      ariaLabel: t("chatBackgroundReplyOpenAriaLabel").replace("{title}", title),
+    });
+  };
+
+  private readonly resolveSessionTitle = (sessionId: string): string => {
+    const summaries =
+      useChatQueryStore.getState().snapshot.sessionsQuery?.data?.sessions ?? [];
+    const summary = summaries.find((item) => item.sessionId === sessionId);
+    return summary
+      ? sessionDisplayName(adaptNcpSessionSummary(summary))
+      : t("chatBackgroundReplyFallbackTitle");
+  };
+
+  private readonly rememberHandledMessage = (messageId: string): void => {
+    this.handledMessageIds.add(messageId);
+    if (this.handledMessageIds.size <= NOTIFIED_MESSAGE_HISTORY_LIMIT) {
+      return;
+    }
+    const oldestMessageId = this.handledMessageIds.values().next().value;
+    if (oldestMessageId) {
+      this.handledMessageIds.delete(oldestMessageId);
+    }
+  };
+}

package/src/features/chat/managers/chat-session-list.manager.ts

@@ -100,9 +100,8 @@ export class ChatSessionListManager {
     this.setSelectedAgentId(normalizedAgentId);
   };
 
-  setSelectedSessionKey = (next: SetStateAction<string | null>) => {
+  private setSelectedSessionKey = (value: string | null) => {
     const prev = useChatSessionListStore.getState().snapshot.selectedSessionKey;
-    const value = this.resolveUpdateValue(prev, next);
     if (value === prev) {
       return;
     }
@@ -111,24 +110,8 @@ export class ChatSessionListManager {
       .setSnapshot({ selectedSessionKey: value });
   };
 
-  syncRouteSessionSelection = (params: {
-    isChatView: boolean;
-    routeSessionKey: string | null;
-  }) => {
-    const { isChatView, routeSessionKey } = params;
-    if (!isChatView) {
-      return;
-    }
-    const { selectedSessionKey } = useChatSessionListStore.getState().snapshot;
-    if (routeSessionKey) {
-      if (selectedSessionKey !== routeSessionKey) {
-        this.setSelectedSessionKey(routeSessionKey);
-      }
-      return;
-    }
-    if (selectedSessionKey !== null) {
-      this.setSelectedSessionKey(null);
-    }
+  syncRouteSessionSelection = (routeSessionKey: string | null) => {
+    this.setSelectedSessionKey(routeSessionKey);
   };
 
   setListMode = (next: SetStateAction<"time-first" | "project-first">) => {
@@ -207,9 +190,6 @@ export class ChatSessionListManager {
     );
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
     const normalizedPrompt = prompt?.trim() || null;
-    useChatSessionListStore.getState().setSnapshot({
-      selectedSessionKey: null,
-    });
     this.syncDraftThreadState();
     this.uiManager.navigateTo(CHAT_DRAFT_SESSION_PATH, {
       replace: this.uiManager.isAtChatRoot(),

package/src/features/chat/managers/chat-thread.manager.ts

@@ -75,10 +75,7 @@ export class ChatThreadManager {
     useChatThreadStore.getState().setSnapshot(patch);
   };
 
-  private clearDeletedSessionState = (sessionKey: string) => {
-    if (useChatSessionListStore.getState().snapshot.selectedSessionKey === sessionKey) {
-      this.sessionListManager.setSelectedSessionKey(null);
-    }
+  private clearDeletedSessionState = () => {
     useChatThreadStore.getState().setSnapshot({
       sessionKey: null,
       sessionTypeLabel: null,
@@ -569,7 +566,7 @@ export class ChatThreadManager {
       await deleteNcpSessionApi(selectedSessionKey);
       deleteNcpSessionSummaryInQueryClient(appQueryClient, selectedSessionKey);
       appQueryClient.removeQueries({ queryKey: ['ncp-session-messages', selectedSessionKey] });
-      this.clearDeletedSessionState(selectedSessionKey);
+      this.clearDeletedSessionState();
       this.uiManager.goToChatRoot({ replace: true });
     } finally {
       useChatThreadStore.getState().setSnapshot({ isDeletePending: false });

package/src/features/chat/pages/__tests__/ncp-chat-page.test.tsx

@@ -1,15 +1,17 @@
 import { render, screen } from '@testing-library/react';
-import { MemoryRouter } from 'react-router-dom';
-import { describe, expect, it, vi } from 'vitest';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { AppPresenterProvider } from '@/app/components/app-presenter-provider';
 import { NcpChatPage } from '@/features/chat/pages/ncp-chat-page';
+import { buildSessionPath } from '@/features/chat/features/session/utils/chat-session-route.utils';
 
 const mocks = vi.hoisted(() => ({
   confirm: vi.fn(),
   consumePending: vi.fn(() => null),
   markConsumed: vi.fn(),
   subscribe: vi.fn(() => vi.fn()),
+  syncActiveSession: vi.fn(),
   useChatSessionSync: vi.fn(),
 }));
 
@@ -21,6 +23,9 @@ vi.mock('@/app/presenters/app.presenter', () => ({
       markConsumed: mocks.markConsumed,
       subscribe: mocks.subscribe,
     },
+    chatCompletionNotificationManager: {
+      syncActiveSession: mocks.syncActiveSession,
+    },
   }),
 }));
 
@@ -34,17 +39,11 @@ vi.mock('@/shared/hooks/use-confirm-dialog', () => ({
 vi.mock('@/features/chat/components/layout/chat-page-shell', () => ({
   ChatPageLayout: () => <div data-testid="chat-page-layout" />,
   useChatSessionSync: (params: {
-    syncRouteSessionSelection: (value: {
-      isChatView: boolean;
-      routeSessionKey: string | null;
-    }) => void;
+    routeSessionKey: string | null;
+    syncRouteSessionSelection: (routeSessionKey: string | null) => void;
   }) => {
     mocks.useChatSessionSync(params);
-    const { syncRouteSessionSelection } = params;
-    syncRouteSessionSelection({
-      isChatView: true,
-      routeSessionKey: null,
-    });
+    params.syncRouteSessionSelection(params.routeSessionKey);
   },
 }));
 
@@ -57,6 +56,11 @@ vi.mock('@/features/chat/features/ncp/hooks/use-ui-show-content-event', () => ({
 }));
 
 describe('NcpChatPage render boundary', () => {
+  beforeEach(() => {
+    mocks.syncActiveSession.mockReset();
+    mocks.useChatSessionSync.mockReset();
+  });
+
   it('creates its chat presenter from the global app presenter provider', () => {
     render(
       <MemoryRouter initialEntries={['/chat']}>
@@ -69,4 +73,21 @@ describe('NcpChatPage render boundary', () => {
     expect(screen.getByTestId('chat-page-layout')).toBeTruthy();
     expect(mocks.useChatSessionSync).toHaveBeenCalledOnce();
   });
+
+  it('syncs the active route session and clears it when chat unmounts', () => {
+    const sessionPath = buildSessionPath('session-background');
+    const view = render(
+      <MemoryRouter initialEntries={[sessionPath]}>
+        <AppPresenterProvider>
+          <Routes>
+            <Route path="/chat/:sessionId?" element={<NcpChatPage view="chat" />} />
+          </Routes>
+        </AppPresenterProvider>
+      </MemoryRouter>,
+    );
+
+    expect(mocks.syncActiveSession).toHaveBeenCalledWith('session-background');
+    view.unmount();
+    expect(mocks.syncActiveSession).toHaveBeenLastCalledWith(null);
+  });
 });

package/src/features/chat/pages/ncp-chat-page.tsx

@@ -59,15 +59,23 @@ export function NcpChatPage({ view }: ChatPageProps) {
 }
 
 function NcpChatPageContent({ view }: ChatPageProps) {
+  const appPresenter = useAppPresenter();
   const presenter = usePresenter();
   const confirmDialog = useNcpChatUiBindings();
   const routeSelection = useNcpChatRouteSelection();
   const { routeSessionKey, sessionKey } = routeSelection;
+  useEffect(() => {
+    appPresenter.chatCompletionNotificationManager.syncActiveSession(
+      sessionKey ?? null,
+    );
+    return () => {
+      appPresenter.chatCompletionNotificationManager.syncActiveSession(null);
+    };
+  }, [appPresenter.chatCompletionNotificationManager, sessionKey]);
   useChatQueryStoreSync({
     sessionKey: sessionKey ?? null,
   });
   useChatSessionSync({
-    view,
     routeSessionKey,
     syncRouteSessionSelection:
       presenter.chatSessionListManager.syncRouteSessionSelection,

package/src/features/chat/types/chat-input-bar.types.ts

@@ -44,6 +44,7 @@ export type ChatInputBarAdapterTexts = {
   modelSearchEmptyLabel: string;
   favoriteModelLabel: string;
   unfavoriteModelLabel: string;
+  manageModelsLabel: string;
   thinkingLabels: Record<ChatThinkingLevel, string>;
   noModelOptionsLabel: string;
   configureProviderLabel: string;

package/src/features/cron/components/cron-task-discovery.tsx

@@ -94,7 +94,7 @@ export const CronTaskComposer = forwardRef<
         ref={ref}
         value={value}
         onChange={(event) => onChange(event.target.value)}
-        className="pl-9 pr-11 focus:border-border/75"
+        className="pl-9 pr-11"
         placeholder={t("cronComposerPlaceholder")}
         aria-label={t("cronComposerLabel")}
       />

package/src/features/inbox/components/inbox-delivery-content.test.tsx

@@ -0,0 +1,57 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { InboxDeliveryContent } from "@/features/inbox/components/inbox-delivery-content";
+
+vi.mock("@nextclaw/agent-chat-ui", () => ({
+  ChatMessageMarkdown: ({ text }: { text: string }) => <article>{text}</article>,
+}));
+
+describe("InboxDeliveryContent", () => {
+  it("keeps Markdown on the existing renderer path", () => {
+    render(
+      <InboxDeliveryContent
+        content="# Markdown report"
+        contentType="markdown"
+        title="Markdown report"
+      />,
+    );
+
+    expect(screen.getByText("# Markdown report")).toBeTruthy();
+    expect(screen.queryByTitle("Markdown report")).toBeNull();
+  });
+
+  it("renders static HTML in an isolated document", () => {
+    render(
+      <InboxDeliveryContent
+        content={'<meta http-equiv="refresh" content="0;url=https://example.com"><h1 onclick="alert(1)">Report</h1><script>alert(1)</script>'}
+        contentType="html"
+        fillHeight
+        title="HTML report"
+      />,
+    );
+
+    const frame = screen.getByTitle<HTMLIFrameElement>("HTML report");
+    expect(frame.getAttribute("sandbox")).toBe("");
+    expect(frame.className).toContain("h-full");
+    expect(frame.className).toContain("border-0");
+    expect(frame.srcdoc).toContain("Content-Security-Policy");
+    expect(frame.srcdoc).toContain("script-src 'none'");
+    expect(frame.srcdoc).toContain("connect-src 'none'");
+    expect(frame.srcdoc).not.toContain("http-equiv=\"refresh\"");
+    expect(frame.srcdoc).not.toContain("onclick");
+    expect(frame.srcdoc).not.toContain("<script");
+  });
+
+  it("preserves the iframe instance while the surrounding view rerenders", () => {
+    const view = render(
+      <InboxDeliveryContent content="<h1>Report</h1>" contentType="html" title="Report" />,
+    );
+    const frame = screen.getByTitle("Report");
+
+    view.rerender(
+      <InboxDeliveryContent content="<h1>Report</h1>" contentType="html" title="Report" />,
+    );
+
+    expect(screen.getByTitle("Report")).toBe(frame);
+  });
+});