@nextclaw/ui 0.15.25 → 0.15.27

package/src/features/chat/features/workspace/stores/workspace-project-tree.store.ts

@@ -0,0 +1,160 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+
+const WORKSPACE_PROJECT_TREE_STORAGE_KEY = 'nextclaw.chat.workspace-project-tree.state';
+const WORKSPACE_PROJECT_TREE_STORAGE_VERSION = 1;
+const MAX_PERSISTED_PROJECT_TREES = 12;
+const MAX_PERSISTED_EXPANDED_PATHS = 256;
+const MAX_PERSISTED_SCROLL_TOP = 10_000_000;
+
+export type WorkspaceProjectTreeViewState = {
+  expandedPaths: string[];
+  scrollTop: number;
+  updatedAt: number;
+};
+
+type WorkspaceProjectTreeStore = {
+  trees: Record<string, WorkspaceProjectTreeViewState>;
+  collapseAll: (rootPath: string) => void;
+  setDirectoryExpanded: (rootPath: string, relativePath: string, expanded: boolean) => void;
+  setScrollTop: (rootPath: string, scrollTop: number) => void;
+};
+
+type PersistedWorkspaceProjectTreeStore = Pick<WorkspaceProjectTreeStore, 'trees'>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object';
+}
+
+export function normalizeWorkspaceProjectTreeRootKey(path: string | null | undefined): string {
+  const normalized = path?.trim().replace(/\\/g, '/').replace(/\/+$/g, '') ?? '';
+  return normalized || (path?.trim() === '/' ? '/' : '');
+}
+
+export function normalizeWorkspaceProjectTreeRelativePath(path: string | null | undefined): string {
+  return path?.trim().replace(/\\/g, '/').replace(/^\/+|\/+$/g, '').replace(/\/{2,}/g, '/') ?? '';
+}
+
+function normalizeScrollTop(value: unknown): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return 0;
+  return Math.min(Math.max(0, Math.round(value)), MAX_PERSISTED_SCROLL_TOP);
+}
+
+function normalizeUpdatedAt(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+
+function normalizeExpandedPaths(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return Array.from(
+    new Set(
+      value
+        .map((path) => (typeof path === 'string' ? normalizeWorkspaceProjectTreeRelativePath(path) : ''))
+        .filter(Boolean),
+    ),
+  ).slice(0, MAX_PERSISTED_EXPANDED_PATHS);
+}
+
+function normalizePersistedTrees(value: unknown): Record<string, WorkspaceProjectTreeViewState> {
+  if (!isRecord(value)) return {};
+  return Object.entries(value)
+    .map(([rootPath, tree]) => {
+      const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+      if (!rootKey || !isRecord(tree)) return null;
+      return [
+        rootKey,
+        {
+          expandedPaths: normalizeExpandedPaths(tree.expandedPaths),
+          scrollTop: normalizeScrollTop(tree.scrollTop),
+          updatedAt: normalizeUpdatedAt(tree.updatedAt),
+        },
+      ] as const;
+    })
+    .filter((entry): entry is readonly [string, WorkspaceProjectTreeViewState] => entry !== null)
+    .sort((left, right) => right[1].updatedAt - left[1].updatedAt)
+    .slice(0, MAX_PERSISTED_PROJECT_TREES)
+    .reduce<Record<string, WorkspaceProjectTreeViewState>>((trees, [rootKey, tree]) => {
+      trees[rootKey] = tree;
+      return trees;
+    }, {});
+}
+
+function retainRecentTrees(
+  trees: Record<string, WorkspaceProjectTreeViewState>,
+): Record<string, WorkspaceProjectTreeViewState> {
+  return normalizePersistedTrees(trees);
+}
+
+function createTreeViewState(): WorkspaceProjectTreeViewState {
+  return { expandedPaths: [], scrollTop: 0, updatedAt: Date.now() };
+}
+
+export const useWorkspaceProjectTreeStore = create<WorkspaceProjectTreeStore>()(
+  persist(
+    (set) => ({
+      trees: {},
+      collapseAll: (rootPath) => {
+        const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+        if (!rootKey) return;
+        set((state) => {
+          const current = state.trees[rootKey];
+          if (!current || current.expandedPaths.length === 0) return state;
+          return {
+            trees: retainRecentTrees({
+              ...state.trees,
+              [rootKey]: { ...current, expandedPaths: [], updatedAt: Date.now() },
+            }),
+          };
+        });
+      },
+      setDirectoryExpanded: (rootPath, relativePath, expanded) => {
+        const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+        const pathKey = normalizeWorkspaceProjectTreeRelativePath(relativePath);
+        if (!rootKey || !pathKey) return;
+        set((state) => {
+          const current = state.trees[rootKey] ?? createTreeViewState();
+          const expandedPaths = expanded
+            ? Array.from(new Set([...current.expandedPaths, pathKey])).slice(0, MAX_PERSISTED_EXPANDED_PATHS)
+            : current.expandedPaths.filter((path) => path !== pathKey);
+          if (
+            expandedPaths.length === current.expandedPaths.length &&
+            expandedPaths.every((path, index) => path === current.expandedPaths[index])
+          ) {
+            return state;
+          }
+          return {
+            trees: retainRecentTrees({
+              ...state.trees,
+              [rootKey]: { ...current, expandedPaths, updatedAt: Date.now() },
+            }),
+          };
+        });
+      },
+      setScrollTop: (rootPath, scrollTop) => {
+        const rootKey = normalizeWorkspaceProjectTreeRootKey(rootPath);
+        if (!rootKey) return;
+        const normalizedScrollTop = normalizeScrollTop(scrollTop);
+        set((state) => {
+          const current = state.trees[rootKey] ?? createTreeViewState();
+          if (current.scrollTop === normalizedScrollTop) return state;
+          return {
+            trees: retainRecentTrees({
+              ...state.trees,
+              [rootKey]: { ...current, scrollTop: normalizedScrollTop, updatedAt: Date.now() },
+            }),
+          };
+        });
+      },
+    }),
+    {
+      name: WORKSPACE_PROJECT_TREE_STORAGE_KEY,
+      version: WORKSPACE_PROJECT_TREE_STORAGE_VERSION,
+      storage: createJSONStorage(() => window.localStorage),
+      partialize: (state): PersistedWorkspaceProjectTreeStore => ({ trees: state.trees }),
+      merge: (persistedState, currentState) => ({
+        ...currentState,
+        trees: normalizePersistedTrees(isRecord(persistedState) ? persistedState.trees : null),
+      }),
+    },
+  ),
+);

package/src/features/chat/index.ts

@@ -4,8 +4,9 @@ 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 { ChatComposerIntentManager } from "./managers/chat-composer-intent.manager";
 export { ChatCompletionNotificationManager } from "./managers/chat-completion-notification.manager";
-export { buildSessionPath } from "./features/session/utils/chat-session-route.utils";
+export { buildSessionPath, CHAT_DRAFT_SESSION_PATH } from "./features/session/utils/chat-session-route.utils";
 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-composer-intent.manager.test.ts

@@ -152,4 +152,33 @@ describe('ChatComposerIntentManager', () => {
       }),
     );
   });
+
+  it('publishes an immutable UI resource reference to the targeted composer', () => {
+    const manager = new ChatComposerIntentManager();
+    const listener = vi.fn();
+    manager.subscribe('session-1', listener);
+    const reference = {
+      uri: 'nextclaw://panel-app/task-board',
+      resourceKind: 'panel-app',
+      title: 'Task board',
+      currentUrl: '/api/panel-apps/task-board/content',
+      contentParams: { boardId: 'today' },
+    };
+
+    manager.requestUiResourceReference({
+      targetSessionKey: 'session-1',
+      reference,
+    });
+    reference.contentParams.boardId = 'mutated';
+
+    expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+      kind: 'ui_resource',
+      targetSessionKey: 'session-1',
+      tokenKey: 'nextclaw://panel-app/task-board',
+      label: 'Task board',
+      reference: expect.objectContaining({
+        contentParams: { boardId: 'today' },
+      }),
+    }));
+  });
 });

package/src/features/chat/managers/chat-composer-intent.manager.ts

@@ -1,8 +1,11 @@
 import {
   CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
+  CHAT_UI_RESOURCE_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
   CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
+  readChatUiResourceReference,
+  type ChatUiResourceReference,
 } from '@nextclaw/shared';
 
 type ChatComposerReferenceIntentBase = {
@@ -35,17 +38,24 @@ export type ChatComposerConversationExcerptIntent = ChatComposerReferenceIntentB
   excerpt: string;
 };
 
+export type ChatComposerUiResourceReferenceIntent = ChatComposerReferenceIntentBase & {
+  kind: typeof CHAT_UI_RESOURCE_TOKEN_KIND;
+  reference: ChatUiResourceReference;
+};
+
 export type ChatComposerReferenceIntent =
   | ChatComposerFileReferenceIntent
   | ChatComposerDirectoryReferenceIntent
   | ChatComposerExcerptReferenceIntent
-  | ChatComposerConversationExcerptIntent;
+  | ChatComposerConversationExcerptIntent
+  | ChatComposerUiResourceReferenceIntent;
 
 type ChatComposerReferenceRequest =
   | Omit<ChatComposerFileReferenceIntent, 'id'>
   | Omit<ChatComposerDirectoryReferenceIntent, 'id'>
   | Omit<ChatComposerExcerptReferenceIntent, 'id'>
-  | Omit<ChatComposerConversationExcerptIntent, 'id'>;
+  | Omit<ChatComposerConversationExcerptIntent, 'id'>
+  | Omit<ChatComposerUiResourceReferenceIntent, 'id'>;
 
 function createExcerptTokenKey(prefix: string, identity: string): string {
   let hash = 2166136261;
@@ -169,6 +179,23 @@ export class ChatComposerIntentManager {
     });
   };
 
+  requestUiResourceReference = (params: {
+    targetSessionKey: string | null;
+    reference: ChatUiResourceReference;
+  }) => {
+    const reference = readChatUiResourceReference(params.reference);
+    if (!reference) return;
+    const tokenKey = reference.uri.trim();
+    const label = reference.title.trim();
+    this.publish({
+      kind: CHAT_UI_RESOURCE_TOKEN_KIND,
+      targetSessionKey: params.targetSessionKey,
+      tokenKey,
+      label,
+      reference,
+    });
+  };
+
   consumePending = (targetSessionKey: string | null): ChatComposerReferenceIntent | null => {
     if (this.pendingIntent?.targetSessionKey !== targetSessionKey) {
       return null;

package/src/features/chat/managers/chat-draft-intent.manager.ts

@@ -1,7 +1,11 @@
+import type { SystemObjectResolvedReference } from '@nextclaw/shared';
+
 export type ChatDraftIntent = {
   id: number;
-  prompt: string;
-};
+} & (
+  | { kind: 'prompt'; prompt: string }
+  | { kind: 'system-object-reference'; reference: SystemObjectResolvedReference }
+);
 
 type ChatDraftIntentListener = (intent: ChatDraftIntent) => void;
 
@@ -17,6 +21,7 @@ export class ChatDraftIntentManager {
     }
     const intent: ChatDraftIntent = {
       id: this.nextId + 1,
+      kind: 'prompt',
       prompt: normalizedPrompt,
     };
     this.nextId = intent.id;
@@ -24,6 +29,17 @@ export class ChatDraftIntentManager {
     this.listeners.forEach((listener) => listener(intent));
   };
 
+  requestSystemObjectReference = (reference: SystemObjectResolvedReference) => {
+    const intent: ChatDraftIntent = {
+      id: this.nextId + 1,
+      kind: 'system-object-reference',
+      reference: structuredClone(reference),
+    };
+    this.nextId = intent.id;
+    this.pendingIntent = intent;
+    this.listeners.forEach((listener) => listener(intent));
+  };
+
   consumePending = (): ChatDraftIntent | null => {
     const intent = this.pendingIntent;
     this.pendingIntent = null;

package/src/features/chat/presenters/chat.presenter.ts

@@ -2,7 +2,7 @@ import { ChatSessionListManager } from '@/features/chat/managers/chat-session-li
 import { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import { ChatQueryManager } from '@/features/chat/managers/chat-query.manager';
 import { ChatThreadManager } from '@/features/chat/managers/chat-thread.manager';
-import { ChatComposerIntentManager } from '@/features/chat/managers/chat-composer-intent.manager';
+import type { ChatComposerIntentManager } from '@/features/chat/managers/chat-composer-intent.manager';
 import type { AppPresenter } from '@/app/presenters/app.presenter';
 
 export class ChatPresenter {
@@ -16,7 +16,7 @@ export class ChatPresenter {
     this.chatUiManager = new ChatUiManager(appPresenter.docBrowserManager);
     this.chatSessionListManager = new ChatSessionListManager(this.chatUiManager);
     this.chatQueryManager = new ChatQueryManager();
-    this.chatComposerIntentManager = new ChatComposerIntentManager();
+    this.chatComposerIntentManager = appPresenter.chatComposerIntentManager;
     this.chatThreadManager = new ChatThreadManager(
       this.chatUiManager,
       this.chatSessionListManager,

package/src/features/chat/stores/__tests__/chat-thread.store.test.ts

@@ -32,6 +32,7 @@ function resetChatThreadStore() {
       closedWorkspaceTabEntries: [],
       workspaceNavigationHistory: [],
       workspaceNavigationHistoryIndex: 0,
+      workspaceExplorerOpen: false,
       workspaceExplorerWidth: CHAT_WORKSPACE_EXPLORER_DEFAULT_WIDTH,
       workspacePanelWidth: CHAT_WORKSPACE_PANEL_DEFAULT_WIDTH,
     },
@@ -74,6 +75,7 @@ describe('chat thread workspace panel persistence', () => {
         { kind: 'file', key: 'session-1::preview::README.md' },
       ],
       workspaceNavigationHistoryIndex: 1,
+      workspaceExplorerOpen: true,
     });
 
     const persisted = JSON.parse(window.localStorage.getItem(chatThreadWorkspaceStorageKey) ?? '{}');
@@ -88,6 +90,7 @@ describe('chat thread workspace panel persistence', () => {
         { kind: 'file', key: 'session-1::preview::README.md' },
       ],
       workspaceNavigationHistoryIndex: 1,
+      workspaceExplorerOpen: true,
     });
     expect(persisted.state.snapshot.sessionKey).toBeUndefined();
     expect(persisted.state.snapshot.isSending).toBeUndefined();
@@ -131,6 +134,7 @@ describe('chat thread workspace panel persistence', () => {
       activeWorkspacePanelKind: 'project-files',
       workspaceNavigationHistory: [{ kind: 'overview' }, { kind: 'child-sessions' }, { kind: 'project-files' }],
       workspaceNavigationHistoryIndex: 2,
+      workspaceExplorerOpen: true,
       workspaceExplorerWidth: 318,
       workspacePanelWidth: 620,
     });
@@ -147,6 +151,7 @@ describe('chat thread workspace panel persistence', () => {
       activeWorkspacePanelKind: 'project-files',
       workspaceNavigationHistory: [{ kind: 'overview' }, { kind: 'child-sessions' }, { kind: 'project-files' }],
       workspaceNavigationHistoryIndex: 2,
+      workspaceExplorerOpen: true,
       workspaceExplorerWidth: 318,
       workspacePanelWidth: 620,
     });
@@ -234,6 +239,7 @@ describe('chat thread workspace panel persistence', () => {
       activeWorkspacePanelKind: 'file',
       activeWorkspaceFileKey: 'session-1::preview::README.md',
       workspaceExplorerWidth: 400,
+      workspaceExplorerOpen: false,
       activeChildSessionKey: 'child-session-1',
       workspaceNavigationHistory: [{ kind: 'file', key: 'session-1::preview::README.md' }],
       workspaceNavigationHistoryIndex: 0,

package/src/features/chat/stores/chat-thread.store.ts

@@ -95,6 +95,7 @@ export type ChatThreadSnapshot = {
   closedWorkspaceTabEntries: ChatWorkspaceNavigationEntry[];
   workspaceNavigationHistory: ChatWorkspaceNavigationEntry[];
   workspaceNavigationHistoryIndex: number;
+  workspaceExplorerOpen: boolean;
   workspaceExplorerWidth: number;
   workspacePanelWidth: number;
   contextWindow?: SessionContextWindowView | null;
@@ -119,6 +120,7 @@ type PersistedChatThreadStore = {
     closedWorkspaceTabEntries?: unknown;
     workspaceNavigationHistory?: unknown;
     workspaceNavigationHistoryIndex?: unknown;
+    workspaceExplorerOpen?: unknown;
     workspaceExplorerWidth?: unknown;
     workspacePanelWidth?: unknown;
   };
@@ -134,6 +136,7 @@ type PersistedChatWorkspaceSnapshot = Pick<
   | 'closedWorkspaceTabEntries'
   | 'workspaceNavigationHistory'
   | 'workspaceNavigationHistoryIndex'
+  | 'workspaceExplorerOpen'
   | 'workspaceExplorerWidth'
   | 'workspacePanelWidth'
 >;
@@ -167,6 +170,7 @@ const initialSnapshot: ChatThreadSnapshot = {
   closedWorkspaceTabEntries: [],
   workspaceNavigationHistory: [],
   workspaceNavigationHistoryIndex: 0,
+  workspaceExplorerOpen: false,
   workspaceExplorerWidth: CHAT_WORKSPACE_EXPLORER_DEFAULT_WIDTH,
   workspacePanelWidth: CHAT_WORKSPACE_PANEL_DEFAULT_WIDTH,
   contextWindow: null,
@@ -281,6 +285,7 @@ function normalizePersistedWorkspaceSnapshot(value: unknown): PersistedChatWorks
     closedWorkspaceTabEntries,
     workspaceNavigationHistory,
     workspaceNavigationHistoryIndex,
+    workspaceExplorerOpen: value.workspaceExplorerOpen === true,
     workspaceExplorerWidth: normalizeChatWorkspaceExplorerWidth(value.workspaceExplorerWidth),
     workspacePanelWidth: normalizeChatWorkspacePanelWidth(value.workspacePanelWidth),
   };
@@ -329,6 +334,7 @@ export const useChatThreadStore = create<ChatThreadStore>()(
             ),
             workspaceNavigationHistory,
             workspaceNavigationHistoryIndex,
+            workspaceExplorerOpen: state.snapshot.workspaceExplorerOpen,
             workspaceExplorerWidth: state.snapshot.workspaceExplorerWidth,
             workspacePanelWidth: state.snapshot.workspacePanelWidth,
           },

package/src/features/inbox/components/inbox-reader-dialog.test.tsx

@@ -1,6 +1,7 @@
-import { render, screen } from "@testing-library/react";
-import { MemoryRouter } from "react-router-dom";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter, useLocation } from "react-router-dom";
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CHAT_DRAFT_SESSION_PATH } from "@/features/chat";
 import { InboxReaderDialog } from "@/features/inbox/components/inbox-reader-dialog";
 import { useInboxStore } from "@/features/inbox/stores/inbox.store";
 import { t } from "@/shared/lib/i18n";
@@ -8,13 +9,17 @@ import { t } from "@/shared/lib/i18n";
 const mocks = vi.hoisted(() => ({
   closeReader: vi.fn(),
   contentType: "markdown",
-  continueInChat: vi.fn(),
+  prepareChatReference: vi.fn(),
+  requestSystemObjectReference: vi.fn(),
   markRead: vi.fn(),
   selectInReader: vi.fn(),
 }));
 
 vi.mock("@/app/components/app-presenter-provider", () => ({
-  useAppPresenter: () => ({ inboxManager: mocks }),
+  useAppPresenter: () => ({
+    inboxManager: mocks,
+    chatDraftIntentManager: { requestSystemObjectReference: mocks.requestSystemObjectReference },
+  }),
 }));
 
 vi.mock("@/features/inbox/hooks/use-inbox-deliveries", () => ({
@@ -34,7 +39,6 @@ vi.mock("@/features/inbox/hooks/use-inbox-deliveries", () => ({
         presentedAt: "2026-08-06T00:01:00.000Z",
         readAt: null,
         archivedAt: null,
-        conversationSessionId: null,
       }],
     },
   }),
@@ -46,10 +50,20 @@ vi.mock("@nextclaw/agent-chat-ui", () => ({
   ),
 }));
 
+function CurrentPath() {
+  return <span data-testid="current-path">{useLocation().pathname}</span>;
+}
+
 describe("InboxReaderDialog", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mocks.contentType = "markdown";
+    mocks.prepareChatReference.mockResolvedValue({
+      reference: {
+        uri: "nextclaw://objects/inbox-delivery/delivery-1",
+        label: "A considered report",
+      },
+    });
     useInboxStore.setState({
       snapshot: { readerOpen: true, activeDeliveryId: "delivery-1" },
     });
@@ -80,4 +94,23 @@ describe("InboxReaderDialog", () => {
       .find((element) => element.tagName === "IFRAME");
     expect(htmlPreview?.className).toContain("h-full");
   });
+
+  it("opens a draft with a visible system object reference intent", async () => {
+    render(
+      <MemoryRouter initialEntries={["/inbox"]}>
+        <InboxReaderDialog />
+        <CurrentPath />
+      </MemoryRouter>,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: t("inboxContinueChat") }));
+
+    await waitFor(() => {
+      expect(screen.getByTestId("current-path").textContent).toBe(CHAT_DRAFT_SESSION_PATH);
+    });
+    expect(mocks.prepareChatReference).toHaveBeenCalledWith("delivery-1");
+    expect(mocks.requestSystemObjectReference).toHaveBeenCalledWith(
+      expect.objectContaining({ uri: "nextclaw://objects/inbox-delivery/delivery-1" }),
+    );
+  });
 });

package/src/features/inbox/components/inbox-reader-dialog.tsx

@@ -2,6 +2,7 @@ import { useRef, useState } from "react";
 import { ChevronLeft, ChevronRight, Inbox } from "lucide-react";
 import { useNavigate } from "react-router-dom";
 import { useAppPresenter } from "@/app/components/app-presenter-provider";
+import { CHAT_DRAFT_SESSION_PATH } from "@/features/chat";
 import { InboxDeliveryContent } from "@/features/inbox/components/inbox-delivery-content";
 import { useInboxDeliveries } from "@/features/inbox/hooks/use-inbox-deliveries";
 import { useInboxStore } from "@/features/inbox/stores/inbox.store";
@@ -25,7 +26,7 @@ function formatPosition(current: number, total: number): string {
 export function InboxReaderDialog() {
   const titleRef = useRef<HTMLHeadingElement>(null);
   const navigate = useNavigate();
-  const { inboxManager } = useAppPresenter();
+  const { chatDraftIntentManager, inboxManager } = useAppPresenter();
   const { data } = useInboxDeliveries();
   const { activeDeliveryId, readerOpen } = useInboxStore((state) => state.snapshot);
   const [pendingAction, setPendingAction] = useState<string | null>(null);
@@ -74,8 +75,9 @@ export function InboxReaderDialog() {
       return;
     }
     void runAction("continue", async () => {
-      const result = await inboxManager.continueInChat(activeDelivery.id);
-      navigate(`/chat/${encodeURIComponent(result.sessionId)}`);
+      const { reference } = await inboxManager.prepareChatReference(activeDelivery.id);
+      chatDraftIntentManager.requestSystemObjectReference(reference);
+      navigate(CHAT_DRAFT_SESSION_PATH);
     });
   };
 

package/src/features/inbox/managers/inbox.manager.test.ts

@@ -6,7 +6,7 @@ import { useInboxStore } from "@/features/inbox/stores/inbox.store";
 
 const mocks = vi.hoisted(() => ({
   delete: vi.fn(),
-  continueInChat: vi.fn(),
+  resolveReference: vi.fn(),
   list: vi.fn(),
   on: vi.fn(() => vi.fn()),
   updateState: vi.fn(),
@@ -17,10 +17,12 @@ vi.mock("@/shared/lib/api", () => ({
     eventBus: { on: mocks.on },
     inboxDeliveries: {
       delete: mocks.delete,
-      continueInChat: mocks.continueInChat,
       list: mocks.list,
       updateState: mocks.updateState,
     },
+    systemObjectReferences: {
+      resolve: mocks.resolveReference,
+    },
   },
 }));
 
@@ -36,7 +38,6 @@ const delivery: InboxDelivery = {
   presentedAt: null,
   readAt: null,
   archivedAt: null,
-  conversationSessionId: null,
 };
 
 describe("InboxManager", () => {
@@ -57,6 +58,19 @@ describe("InboxManager", () => {
       presentedAt: action === "present" || action === "read" ? "2026-08-06T01:00:00.000Z" : null,
       readAt: action === "read" ? "2026-08-06T01:00:00.000Z" : null,
     }));
+    mocks.resolveReference.mockResolvedValue({
+      uri: "nextclaw://objects/inbox-delivery/delivery-1",
+      objectType: "inbox-delivery",
+      objectId: "delivery-1",
+      label: "Brief",
+      description: null,
+      updatedAt: delivery.updatedAt,
+      version: "version-1",
+      assetUri: "asset://store/report",
+      fileName: "brief.md",
+      mimeType: "text/markdown",
+      sizeBytes: 7,
+    });
   });
 
   it("auto-opens the oldest unpresented item and only marks it presented", async () => {
@@ -83,4 +97,15 @@ describe("InboxManager", () => {
     expect(mocks.updateState).toHaveBeenCalledTimes(1);
     expect(mocks.updateState).toHaveBeenCalledWith(delivery.id, "present");
   });
+
+  it("prepares a generic immutable report reference before marking it read", async () => {
+    const manager = new InboxManager(new QueryClient());
+    const result = await manager.prepareChatReference(delivery.id);
+
+    expect(mocks.resolveReference).toHaveBeenCalledWith(
+      "nextclaw://objects/inbox-delivery/delivery-1",
+    );
+    expect(mocks.updateState).toHaveBeenCalledWith(delivery.id, "read");
+    expect(result.reference.assetUri).toBe("asset://store/report");
+  });
 });

package/src/features/inbox/managers/inbox.manager.ts

@@ -5,6 +5,11 @@ import type {
   InboxDeliveryStateAction,
 } from "@nextclaw/shared";
 import { eventKeys } from "@nextclaw/shared";
+import {
+  createSystemObjectReferenceUri,
+  SYSTEM_OBJECT_TYPE_INBOX_DELIVERY,
+  type SystemObjectResolvedReference,
+} from "@nextclaw/shared";
 import { appQueryClient } from "@/app-query-client";
 import { useInboxStore } from "@/features/inbox/stores/inbox.store";
 import { nextclawClient } from "@/shared/lib/api";
@@ -104,11 +109,16 @@ export class InboxManager {
     return deleted;
   };
 
-  continueInChat = async (deliveryId: string) => {
-    const result = await nextclawClient.inboxDeliveries.continueInChat(deliveryId);
-    this.replaceCachedDelivery(result.delivery);
+  prepareChatReference = async (deliveryId: string): Promise<{
+    delivery: InboxDelivery;
+    reference: SystemObjectResolvedReference;
+  }> => {
+    const reference = await nextclawClient.systemObjectReferences.resolve(
+      createSystemObjectReferenceUri(SYSTEM_OBJECT_TYPE_INBOX_DELIVERY, deliveryId),
+    );
+    const delivery = await this.updateState(deliveryId, "read");
     this.closeReader();
-    return result;
+    return { delivery, reference };
   };
 
   private updateState = async (