@nextclaw/ui 0.15.19 → 0.15.21

package/src/features/chat/features/input/utils/chat-composer-token-protocol.utils.ts

@@ -1,10 +1,12 @@
 import {
+  CHAT_PROJECT_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
 } from '@nextclaw/shared';
 
 const CHAT_SKILL_TOKEN_PREFIX = '$';
 const CHAT_PANEL_APP_TOKEN_PREFIX = '@panel-app:';
+const CHAT_PROJECT_TOKEN_PREFIX = '@project:';
 const CHAT_WORKSPACE_FILE_TOKEN_PREFIX = '@file:';
 const CHAT_WORKSPACE_DIRECTORY_TOKEN_PREFIX = '@folder:';
 
@@ -20,6 +22,9 @@ export function serializeChatComposerTokenText(params: {
   if (tokenKind === 'panel_app') {
     return `${CHAT_PANEL_APP_TOKEN_PREFIX}${tokenKey}`;
   }
+  if (tokenKind === CHAT_PROJECT_TOKEN_KIND) {
+    return `${CHAT_PROJECT_TOKEN_PREFIX}${encodeURIComponent(tokenKey)}`;
+  }
   if (tokenKind === CHAT_WORKSPACE_FILE_TOKEN_KIND) {
     return `${CHAT_WORKSPACE_FILE_TOKEN_PREFIX}${encodeURIComponent(tokenKey)}`;
   }

package/src/features/chat/features/input/utils/chat-inline-token.utils.ts

@@ -2,6 +2,7 @@ import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import {
   CHAT_INLINE_TOKENS_METADATA_KEY,
   CHAT_INLINE_TOKENS_SCHEMA_VERSION,
+  CHAT_PROJECT_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
   type ChatInlineTokenMetadata,
@@ -13,6 +14,7 @@ import { serializeChatComposerTokenText } from './chat-composer-token-protocol.u
 export { CHAT_INLINE_TOKENS_METADATA_KEY };
 const CHAT_PANEL_APP_TOKEN_PREFIX = '@panel-app:';
 const CHAT_PANEL_APP_TOKEN_PATTERN = /@panel-app:([A-Za-z0-9_-]+)/g;
+const CHAT_PROJECT_TOKEN_PATTERN = /@project:([^\s]+)/g;
 const CHAT_WORKSPACE_FILE_TOKEN_PATTERN = /@file:([^\s]+)/g;
 const CHAT_WORKSPACE_DIRECTORY_TOKEN_PATTERN = /@folder:([^\s]+)/g;
 
@@ -96,6 +98,7 @@ export function buildInlineTokensFromComposer(
     }
     if (
       node.tokenKind !== 'skill' &&
+      node.tokenKind !== CHAT_PROJECT_TOKEN_KIND &&
       node.tokenKind !== CHAT_WORKSPACE_FILE_TOKEN_KIND &&
       node.tokenKind !== CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND
     ) {
@@ -121,6 +124,15 @@ export function buildInlineTokensFromComposer(
       });
       continue;
     }
+    if (node.tokenKind === CHAT_PROJECT_TOKEN_KIND) {
+      tokens.push({
+        kind: CHAT_PROJECT_TOKEN_KIND,
+        key: node.tokenKey,
+        label: node.label,
+        rawText,
+      });
+      continue;
+    }
     const workspaceKind = node.tokenKind === CHAT_WORKSPACE_FILE_TOKEN_KIND
       ? CHAT_WORKSPACE_FILE_TOKEN_KIND
       : CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
@@ -134,8 +146,11 @@ export function buildInlineTokensFromComposer(
   return dedupeInlineTokens(tokens);
 }
 
-function appendWorkspaceTokens(params: {
-  kind: typeof CHAT_WORKSPACE_FILE_TOKEN_KIND | typeof CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
+function appendEncodedKeyTokens(params: {
+  kind:
+    | typeof CHAT_PROJECT_TOKEN_KIND
+    | typeof CHAT_WORKSPACE_FILE_TOKEN_KIND
+    | typeof CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
   pattern: RegExp;
   text: string;
   tokens: ChatInlineTokenSource[];
@@ -155,7 +170,7 @@ function appendWorkspaceTokens(params: {
     tokens.push({
       kind,
       key,
-      label: key.split('/').filter(Boolean).at(-1) ?? key,
+      label: key.split(/[\\/]+/).filter(Boolean).at(-1) ?? key,
       rawText: match[0],
     });
   }
@@ -175,13 +190,19 @@ export function buildInlineTokensFromTextProtocol(text: string): ChatInlineToken
       rawText: `${CHAT_PANEL_APP_TOKEN_PREFIX}${key}`
     });
   }
-  appendWorkspaceTokens({
+  appendEncodedKeyTokens({
+    kind: CHAT_PROJECT_TOKEN_KIND,
+    pattern: CHAT_PROJECT_TOKEN_PATTERN,
+    text,
+    tokens,
+  });
+  appendEncodedKeyTokens({
     kind: CHAT_WORKSPACE_FILE_TOKEN_KIND,
     pattern: CHAT_WORKSPACE_FILE_TOKEN_PATTERN,
     text,
     tokens,
   });
-  appendWorkspaceTokens({
+  appendEncodedKeyTokens({
     kind: CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
     pattern: CHAT_WORKSPACE_DIRECTORY_TOKEN_PATTERN,
     text,

package/src/features/chat/features/message/components/__tests__/chat-message-list.container.test.tsx

@@ -453,7 +453,7 @@ it("wires markdown file link actions to the workspace file preview manager", ()
   expect(captures.openFilePreview).toHaveBeenCalledWith(action);
 });
 
-it("opens workspace file and directory tokens from the message", () => {
+it("opens workspace and project reference tokens from the message", () => {
   captures.selectedSession = {
     projectRoot: "/tmp/project",
     workingDir: "/tmp/project/packages/ui",
@@ -474,6 +474,12 @@ it("opens workspace file and directory tokens from the message", () => {
     label: "server",
     rawText: "@folder:packages%2Fserver",
   });
+  onInlineTokenClick?.({
+    kind: "project",
+    key: "/tmp/nextclaw",
+    label: "NextClaw",
+    rawText: "@project:%2Ftmp%2Fnextclaw",
+  });
 
   expect(captures.openFilePreview).toHaveBeenNthCalledWith(1, {
     path: "/tmp/project/docs/guide.md",
@@ -485,6 +491,11 @@ it("opens workspace file and directory tokens from the message", () => {
     label: "server",
     viewMode: "preview",
   });
+  expect(captures.openFilePreview).toHaveBeenNthCalledWith(3, {
+    path: "/tmp/nextclaw",
+    label: "NextClaw",
+    viewMode: "preview",
+  });
 });
 
 it("opens panel app tokens through the existing content owner", () => {

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

@@ -6,6 +6,7 @@ import {
   type RefObject,
 } from "react";
 import type { NcpMessage } from "@nextclaw/ncp";
+import { CHAT_PROJECT_TOKEN_KIND } from "@nextclaw/shared";
 import { toast } from "sonner";
 import {
   type ChatInlineDisplayViewModel,
@@ -346,13 +347,16 @@ export function ChatMessageListContainer({
       }
       if (
         "key" in token &&
-        (token.kind === "workspace_file" ||
+        (token.kind === CHAT_PROJECT_TOKEN_KIND ||
+          token.kind === "workspace_file" ||
           token.kind === "workspace_directory")
       ) {
-        const path = resolveWorkspaceReferencePath({
-          projectRoot: selectedSession?.projectRoot,
-          relativePath: token.key,
-        });
+        const path = token.kind === CHAT_PROJECT_TOKEN_KIND
+          ? token.key
+          : resolveWorkspaceReferencePath({
+              projectRoot: selectedSession?.projectRoot,
+              relativePath: token.key,
+            });
         if (path) {
           presenter.chatThreadManager.openFilePreview({
             path,

package/src/features/chat/index.ts

@@ -4,6 +4,7 @@ export { ChatPresenterProvider } from "./components/providers/chat-presenter.pro
 export { usePresenter } from "./components/providers/chat-presenter.provider";
 export { ChatPresenter } from "./presenters/chat.presenter";
 export { ChatDraftIntentManager } from "./managers/chat-draft-intent.manager";
+export { ChatCompletionNotificationManager } from "./managers/chat-completion-notification.manager";
 export { useChatSessionListStore } from "./stores/chat-session-list.store";
 export { useChatThreadStore } from "./stores/chat-thread.store";
 export { useChatMessageLayoutStore } from "./stores/chat-message-layout.store";

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/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/pages/__tests__/ncp-chat-page.test.ts

@@ -272,6 +272,32 @@ describe('buildChatRunMetadata', () => {
     });
   });
 
+  it('adds structured project references to run metadata', () => {
+    expect(
+      buildChatRunMetadata({
+        composerNodes: [
+          createChatComposerTokenNode({
+            tokenKind: 'project',
+            tokenKey: '/tmp/nextclaw',
+            label: 'NextClaw',
+          }),
+        ],
+      }),
+    ).toMatchObject({
+      ui_inline_tokens: {
+        schemaVersion: 2,
+        items: [
+          {
+            kind: 'project',
+            key: '/tmp/nextclaw',
+            label: 'NextClaw',
+            rawText: '@project:%2Ftmp%2Fnextclaw',
+          },
+        ],
+      },
+    });
+  });
+
   it('serializes child session materialization metadata for side chat drafts', () => {
     expect(
       buildChatRunMetadata({

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,
+    },
   }),
 }));
 
@@ -57,6 +62,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 +79,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,10 +59,19 @@ 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,
   });

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);
+  });
+});