@nextclaw/ui 0.15.4 → 0.15.6

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

@@ -4,13 +4,11 @@ import {
   type ChatInlineDisplayViewModel,
   type ChatInlineTokenViewModel,
   type ChatMessageViewModel,
+  type ChatPanelAppCardViewModel,
   ChatMessageList,
 } from "@nextclaw/agent-chat-ui";
 import { usePresenter } from "@/features/chat/components/providers/chat-presenter.provider";
-import {
-  adaptChatMessage,
-  type ChatMessageSource,
-} from "@/features/chat/features/message/utils/chat-message.utils";
+import { adaptChatMessage, type ChatMessageSource } from "@/features/chat/features/message/utils/chat-message.utils";
 import { buildChatMessageProcessSummary } from "@/features/chat/features/message/utils/chat-message-process-summary.utils";
 import {
   buildChatMessageAdapterTexts,
@@ -23,6 +21,7 @@ import {
   type ContextCompactionTimelineView,
 } from "@/features/chat/features/session/utils/ncp-session-context-metadata.utils";
 import { AgentIdentityAvatar } from "@/shared/components/common/agent-identity";
+import { ChatInlineFilePreview } from "@/features/chat/features/message/components/chat-inline-file-preview";
 import { ChatInlinePanelAppCard } from "@/features/chat/features/message/components/chat-inline-panel-app-card";
 import { useChatQueryStore } from "@/features/chat/stores/ncp-chat-query.store";
 import { useChatSessionListStore } from "@/features/chat/stores/chat-session-list.store";
@@ -62,6 +61,10 @@ function renderChatInlineDisplay(display: ChatInlineDisplayViewModel) {
     />
   );
 }
+
+const renderChatToolAgent = (agentId: string) => <AgentIdentityAvatar agentId={agentId} className="h-4 w-4 shrink-0" />;
+const renderChatPanelAppCard = (panelApp: ChatPanelAppCardViewModel) => <ChatInlinePanelAppCard panelApp={panelApp} />;
+
 type ContextInheritanceTimelineView = {
   sourceSessionId: string;
   inheritedMessageCount: number;
@@ -88,11 +91,7 @@ type ChatTimelineItem =
       inheritance: ContextInheritanceTimelineView;
     };
 
-function ChatContextCompactionDivider({
-  checkpoint,
-}: {
-  checkpoint: ContextCompactionTimelineView;
-}) {
+function ChatContextCompactionDivider({ checkpoint }: { checkpoint: ContextCompactionTimelineView }) {
   const title = [
     `${t("chatContextCompactionCoveredMessages")}: ${checkpoint.coveredSessionMessageCount}`,
     `${t("chatContextCompactionOriginalTokens")}: ${checkpoint.originalEstimatedTokens}`,
@@ -118,11 +117,7 @@ function ChatContextCompactionDivider({
   );
 }
 
-function ChatContextInheritanceDivider({
-  inheritance,
-}: {
-  inheritance: ContextInheritanceTimelineView;
-}) {
+function ChatContextInheritanceDivider({ inheritance }: { inheritance: ContextInheritanceTimelineView }) {
   const title = [
     `${t("chatContextInheritanceSourceSession")}: ${inheritance.sourceSessionId}`,
     `${t("chatContextInheritanceMessages")}: ${inheritance.inheritedMessageCount}`,
@@ -144,20 +139,12 @@ function resolveCompactionBoundaryIndex(params: {
   visibleRawMessages: readonly NcpMessage[];
   rawMessageId: string;
 }): number {
-  const {
-    rawMessageId,
-    rawMessages,
-    visibleRawMessages,
-  } = params;
-  const physicalIndex = rawMessages.findIndex(
-    (message) => message.id === rawMessageId,
-  );
+  const { rawMessageId, rawMessages, visibleRawMessages } = params;
+  const physicalIndex = rawMessages.findIndex((message) => message.id === rawMessageId);
   if (physicalIndex < 0) {
     return visibleRawMessages.length - 1;
   }
-  const previousVisibleCount = rawMessages
-    .slice(0, physicalIndex)
-    .filter(isVisibleChatMessage).length;
+  const previousVisibleCount = rawMessages.slice(0, physicalIndex).filter(isVisibleChatMessage).length;
   return previousVisibleCount - 1;
 }
 
@@ -170,9 +157,7 @@ function isVisibleChatMessage(message: NcpMessage): boolean {
   return !readContextCompactionTimeline(message) && !readInheritedSourceSessionId(message);
 }
 
-function resolveContextInheritanceBoundary(
-  messages: readonly NcpMessage[],
-): ContextInheritanceTimelineBoundary | null {
+function resolveContextInheritanceBoundary(messages: readonly NcpMessage[]): ContextInheritanceTimelineBoundary | null {
   const boundaryIndex = messages.findIndex((message) => readInheritedSourceSessionId(message));
   if (boundaryIndex < 0) {
     return null;
@@ -184,7 +169,8 @@ function resolveContextInheritanceBoundary(
   return {
     boundaryIndex: messages.slice(0, boundaryIndex).filter(isVisibleChatMessage).length,
     sourceSessionId,
-    inheritedMessageCount: messages.filter((message) => readInheritedSourceSessionId(message) === sourceSessionId).length,
+    inheritedMessageCount: messages.filter((message) => readInheritedSourceSessionId(message) === sourceSessionId)
+      .length,
   };
 }
 
@@ -199,8 +185,12 @@ function buildTimelineItems(params: {
       checkpoint: readContextCompactionTimeline(message),
     }))
     .filter(
-      (entry): entry is { rawMessageId: string; checkpoint: ContextCompactionTimelineView } =>
-        Boolean(entry.checkpoint),
+      (
+        entry,
+      ): entry is {
+        rawMessageId: string;
+        checkpoint: ContextCompactionTimelineView;
+      } => Boolean(entry.checkpoint),
     )
     .map((entry) => ({
       key: entry.rawMessageId,
@@ -290,19 +280,35 @@ export function ChatMessageListContainer({
   const presenter = usePresenter();
   const { language } = useI18n();
   const messageLayout = useChatMessageLayoutStore((state) => state.layout);
-  const selectedSessionKey = useChatSessionListStore(
-    (state) => state.snapshot.selectedSessionKey,
-  );
+  const selectedSessionKey = useChatSessionListStore((state) => state.snapshot.selectedSessionKey);
   const selectedSession = useNcpChatSelectedSession(selectedSessionKey);
   const localFileBasePath = selectedSession?.workingDir ?? selectedSession?.projectRoot ?? null;
+  const renderInlineDisplayWithFiles = useCallback(
+    (display: ChatInlineDisplayViewModel) => {
+      const panelAppDisplay = renderChatInlineDisplay(display);
+      if (panelAppDisplay) {
+        return panelAppDisplay;
+      }
+      if (display.target.type === "file") {
+        return (
+          <ChatInlineFilePreview
+            display={display}
+            parentSessionKey={selectedSessionKey}
+            sessionProjectRoot={selectedSession?.projectRoot ?? null}
+            sessionWorkingDir={localFileBasePath}
+            onFileOpen={presenter.chatThreadManager.openFilePreview}
+          />
+        );
+      }
+      return undefined;
+    },
+    [localFileBasePath, presenter.chatThreadManager, selectedSession?.projectRoot, selectedSessionKey],
+  );
   const resolveFileContentUrl = useCallback(
     (action: { path: string }) => buildServerPathContentUrl(action.path, localFileBasePath),
     [localFileBasePath],
   );
-  const texts = useMemo(
-    () => buildChatMessageAdapterTexts(language),
-    [language],
-  );
+  const texts = useMemo(() => buildChatMessageAdapterTexts(language), [language]);
 
   const messages = useMemo(() => {
     const visibleRawMessages = rawMessages.filter(isVisibleChatMessage);
@@ -335,7 +341,11 @@ export function ChatMessageListContainer({
         texts,
       });
 
-      messageViewModelCache.set(message, { language, processSummaryLabel, viewModel });
+      messageViewModelCache.set(message, {
+        language,
+        processSummaryLabel,
+        viewModel,
+      });
       return [viewModel];
     });
   }, [language, rawMessages, texts]);
@@ -343,20 +353,12 @@ export function ChatMessageListContainer({
   const hasAssistantDraft = useMemo(
     () =>
       messages.some(
-        (message) =>
-          message.role === "assistant" &&
-          (message.status === "streaming" || message.status === "pending"),
+        (message) => message.role === "assistant" && (message.status === "streaming" || message.status === "pending"),
       ),
     [messages],
   );
-  const messageTexts = useMemo(
-    () => buildChatMessageTexts(language),
-    [language],
-  );
-  const timelineItems = useMemo(
-    () => buildTimelineItems({ rawMessages, messages }),
-    [messages, rawMessages],
-  );
+  const messageTexts = useMemo(() => buildChatMessageTexts(language), [language]);
+  const timelineItems = useMemo(() => buildTimelineItems({ rawMessages, messages }), [messages, rawMessages]);
   const sessionSkillsQuery = useChatQueryStore((state) => state.snapshot.sessionSkillsQuery);
   const handleInlineTokenClick = useCallback(
     (token: ChatInlineTokenViewModel) => {
@@ -419,16 +421,9 @@ export function ChatMessageListContainer({
             onAttachmentOpen={handleAttachmentOpen}
             onInlineTokenClick={handleInlineTokenClick}
             resolveFileContentUrl={resolveFileContentUrl}
-            renderInlineDisplay={renderChatInlineDisplay}
-            renderToolAgent={(agentId) => (
-              <AgentIdentityAvatar
-                agentId={agentId}
-                className="h-4 w-4 shrink-0"
-              />
-            )}
-            renderPanelAppCard={(panelApp) => (
-              <ChatInlinePanelAppCard panelApp={panelApp} />
-            )}
+            renderInlineDisplay={renderInlineDisplayWithFiles}
+            renderToolAgent={renderChatToolAgent}
+            renderPanelAppCard={renderChatPanelAppCard}
           />
         ),
       )}

package/src/features/chat/features/message/utils/chat-message-texts.utils.ts

@@ -106,6 +106,8 @@ export function buildChatMessageTexts(
     copiedCodeLabel: t("chatCodeCopied"),
     copyMessageLabel: t("chatMessageCopy"),
     copiedMessageLabel: t("chatMessageCopied"),
+    mermaidDiagramLabel: t("chatMermaidDiagram"),
+    mermaidRenderErrorLabel: t("chatMermaidRenderError"),
     typingLabel: t("chatTyping"),
     reasoningCharacterCountTemplates: {
       inProgress: t("chatReasoningInProgressCharacterCount"),

package/src/features/chat/features/ncp/hooks/__tests__/use-hydrated-ncp-agent.test.tsx

@@ -1,19 +1,57 @@
-import { renderHook, waitFor } from "@testing-library/react";
-import type { NcpAgentClientEndpoint } from "@nextclaw/ncp";
-import { useHydratedNcpAgent } from "@nextclaw/ncp-react";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { NcpEventType, type NcpAgentClientEndpoint } from "@nextclaw/ncp";
+import { useHydratedNcpAgent, useNcpAgentRuntime } from "@nextclaw/ncp-react";
+import { DefaultNcpAgentConversationStateManager } from "@nextclaw/ncp-toolkit";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => ({
+  send: vi.fn(),
   stream: vi.fn(),
   stop: vi.fn(),
 }));
 
 describe("useHydratedNcpAgent", () => {
   beforeEach(() => {
+    mocks.send.mockReset();
     mocks.stream.mockReset();
     mocks.stop.mockReset();
   });
 
+  it("clears a draft conversation error when a valid retry starts", async () => {
+    const client = {
+      send: mocks.send.mockResolvedValue(null),
+      stop: mocks.stop.mockResolvedValue(undefined),
+      stream: mocks.stream.mockResolvedValue(undefined),
+      subscribe: vi.fn(() => () => {}),
+    } as unknown as NcpAgentClientEndpoint;
+    const manager = new DefaultNcpAgentConversationStateManager();
+    const { result } = renderHook(() =>
+      useNcpAgentRuntime({
+        client,
+        manager,
+      }),
+    );
+
+    await act(async () => {
+      await manager.dispatch({
+        occurredAt: new Date().toISOString(),
+        type: NcpEventType.EndpointError,
+        payload: {
+          code: "runtime-error",
+          message: "network error",
+        },
+      });
+    });
+    expect(result.current.snapshot.error?.message).toBe("network error");
+
+    await act(async () => {
+      await result.current.send("retry");
+    });
+
+    expect(result.current.snapshot.error).toBeNull();
+    expect(mocks.send).toHaveBeenCalledOnce();
+  });
+
   it("treats a newly selected session as hydrating immediately on rerender", async () => {
     const client = {
       stop: mocks.stop.mockResolvedValue(undefined),

package/src/features/chat/features/project/components/__tests__/chat-project-create-dialog.test.tsx

@@ -0,0 +1,67 @@
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import { ChatProjectCreateDialog } from '@/features/chat/features/project/components/chat-project-create-dialog';
+import { setLanguage } from '@/shared/lib/i18n';
+
+const pathPickerSpy = vi.fn();
+
+vi.mock('@/shared/components/path-picker/server-path-picker-dialog', () => ({
+  ServerPathPickerDialog: (props: unknown) => pathPickerSpy(props),
+}));
+
+describe('ChatProjectCreateDialog', () => {
+  it('selects the optional target directory with the shared path picker', async () => {
+    setLanguage('zh');
+    const user = userEvent.setup();
+    const onCreate = vi.fn(async () => undefined);
+
+    render(
+      <ChatProjectCreateDialog
+        open
+        defaultWorkspacePath="/workspace"
+        templates={[
+          { id: 'empty', name: 'Empty', description: 'Empty project' },
+          {
+            id: 'knowledge-base',
+            name: 'Knowledge base',
+            description: 'Knowledge base project',
+          },
+        ]}
+        isCreating={false}
+        onOpenChange={() => {}}
+        onCreate={onCreate}
+      />,
+    );
+
+    await user.type(screen.getByLabelText('项目名称'), '个人知识库');
+    fireEvent.change(document.querySelector('select')!, {
+      target: { value: 'knowledge-base' },
+    });
+    await user.click(screen.getByRole('button', { name: '浏览' }));
+    expect(pathPickerSpy).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        open: true,
+        currentPath: '',
+        defaultWorkspacePath: '/workspace',
+        title: '选择项目目标目录',
+      }),
+    );
+    const pickerProps = pathPickerSpy.mock.lastCall?.[0] as {
+      onConfirm: (path: string) => void;
+    };
+    act(() => pickerProps.onConfirm('/srv/knowledge'));
+    expect((screen.getByLabelText('目标目录（可选）') as HTMLInputElement).value).toBe(
+      '/srv/knowledge',
+    );
+    await user.click(screen.getByRole('button', { name: '创建项目' }));
+
+    await waitFor(() => {
+      expect(onCreate).toHaveBeenCalledWith({
+        name: '个人知识库',
+        rootPath: '/srv/knowledge',
+        template: 'knowledge-base',
+      });
+    });
+  });
+});

package/src/features/chat/features/project/components/chat-project-create-dialog.tsx

@@ -0,0 +1,203 @@
+import { useState } from 'react';
+import { FolderOpen } from 'lucide-react';
+import type { ProjectCreateRequest, ProjectTemplateView } from '@/shared/lib/api';
+import { ServerPathPickerDialog } from '@/shared/components/path-picker/server-path-picker-dialog';
+import { Button } from '@/shared/components/ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/shared/components/ui/dialog';
+import { Input } from '@/shared/components/ui/input';
+import { Label } from '@/shared/components/ui/label';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/shared/components/ui/select';
+import { t } from '@/shared/lib/i18n';
+
+type ProjectTemplateId = NonNullable<ProjectCreateRequest['template']>;
+
+type ChatProjectCreateDialogProps = {
+  open: boolean;
+  defaultWorkspacePath?: string | null;
+  templates: readonly ProjectTemplateView[];
+  isCreating: boolean;
+  errorMessage?: string | null;
+  onOpenChange: (open: boolean) => void;
+  onCreate: (input: ProjectCreateRequest) => Promise<void>;
+};
+
+function projectTemplateLabel(templateId: ProjectTemplateId): string {
+  return t(
+    templateId === 'knowledge-base'
+      ? 'chatProjectTemplateKnowledgeBase'
+      : 'chatProjectTemplateEmpty',
+  );
+}
+
+export function ChatProjectCreateDialog({
+  open,
+  defaultWorkspacePath,
+  templates,
+  isCreating,
+  errorMessage,
+  onOpenChange,
+  onCreate,
+}: ChatProjectCreateDialogProps) {
+  const [name, setName] = useState('');
+  const [rootPath, setRootPath] = useState('');
+  const [pathPickerOpen, setPathPickerOpen] = useState(false);
+  const [template, setTemplate] = useState<ProjectTemplateId>('empty');
+  const availableTemplateIds = templates.length > 0
+    ? templates.map((entry) => entry.id)
+    : ['empty' as const];
+  const normalizedName = name.trim();
+
+  const resetForm = () => {
+    setName('');
+    setRootPath('');
+    setTemplate('empty');
+    setPathPickerOpen(false);
+  };
+
+  const closeDialog = () => {
+    if (isCreating) {
+      return;
+    }
+    resetForm();
+    onOpenChange(false);
+  };
+
+  return (
+    <>
+      <Dialog
+        open={open}
+        onOpenChange={(nextOpen) => {
+          if (nextOpen) {
+            onOpenChange(true);
+            return;
+          }
+          closeDialog();
+        }}
+      >
+        <DialogContent className="sm:max-w-lg">
+          <DialogHeader>
+            <DialogTitle>{t('chatProjectCreateTitle')}</DialogTitle>
+            <DialogDescription>{t('chatProjectCreateDescription')}</DialogDescription>
+          </DialogHeader>
+          <form
+            className="space-y-4"
+            onSubmit={(event) => {
+              event.preventDefault();
+              if (!normalizedName || isCreating) {
+                return;
+              }
+              const normalizedRootPath = rootPath.trim();
+              void onCreate({
+                name: normalizedName,
+                template,
+                ...(normalizedRootPath ? { rootPath: normalizedRootPath } : {}),
+              }).then(resetForm).catch(() => undefined);
+            }}
+          >
+            <div className="space-y-2">
+              <Label htmlFor="chat-project-name">{t('chatProjectNameLabel')}</Label>
+              <Input
+                id="chat-project-name"
+                value={name}
+                onChange={(event) => setName(event.target.value)}
+                placeholder={t('chatProjectNamePlaceholder')}
+                autoFocus
+                disabled={isCreating}
+              />
+            </div>
+
+            <div className="space-y-2">
+              <Label htmlFor="chat-project-template">{t('chatProjectTemplateLabel')}</Label>
+              <Select
+                value={template}
+                onValueChange={(value) => setTemplate(value as ProjectTemplateId)}
+                disabled={isCreating}
+              >
+                <SelectTrigger id="chat-project-template">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {availableTemplateIds.map((templateId) => (
+                    <SelectItem key={templateId} value={templateId}>
+                      {projectTemplateLabel(templateId)}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div className="space-y-2">
+              <Label htmlFor="chat-project-root-path">{t('chatProjectPathLabel')}</Label>
+              <div className="flex gap-2">
+                <Input
+                  id="chat-project-root-path"
+                  value={rootPath}
+                  onChange={(event) => setRootPath(event.target.value)}
+                  placeholder={t('chatProjectPathPlaceholder')}
+                  disabled={isCreating}
+                />
+                <Button
+                  type="button"
+                  variant="outline"
+                  onClick={() => setPathPickerOpen(true)}
+                  disabled={isCreating}
+                >
+                  <FolderOpen className="mr-2 h-4 w-4" />
+                  {t('browse')}
+                </Button>
+              </div>
+              <p className="text-xs leading-relaxed text-muted-foreground">
+                {t('chatProjectPathHint')}
+              </p>
+            </div>
+
+            {errorMessage ? (
+              <p role="alert" className="text-sm text-destructive">
+                {errorMessage}
+              </p>
+            ) : null}
+
+            <DialogFooter>
+              <Button type="button" variant="outline" onClick={closeDialog} disabled={isCreating}>
+                {t('cancel')}
+              </Button>
+              <Button type="submit" disabled={!normalizedName || isCreating}>
+                {isCreating ? t('saving') : t('chatProjectCreateAction')}
+              </Button>
+            </DialogFooter>
+          </form>
+        </DialogContent>
+      </Dialog>
+      <ServerPathPickerDialog
+        open={pathPickerOpen}
+        currentPath={rootPath}
+        defaultWorkspacePath={defaultWorkspacePath}
+        isSaving={false}
+        onOpenChange={setPathPickerOpen}
+        onConfirm={(path) => {
+          setRootPath(path);
+          setPathPickerOpen(false);
+        }}
+        title={t('chatProjectPathPickerTitle')}
+        description={t('chatProjectPathPickerDescription')}
+        pathLabel={t('chatProjectPathLabel')}
+        pathPlaceholder={t('chatProjectPathPlaceholder')}
+        confirmLabel={t('selectCurrentDirectory')}
+        hint={t('chatProjectPathHint')}
+      />
+    </>
+  );
+}

package/src/features/chat/features/session/components/session-header/__tests__/chat-session-header-actions.test.tsx

@@ -32,7 +32,7 @@ describe('ChatSessionHeaderActions', () => {
         sessionKey="session-1"
         canDeleteSession
         isDeletePending={false}
-        projectRoot="/tmp/project-alpha"
+        currentPath="/tmp/project-alpha"
         isWorkspaceOpen={false}
         onToggleWorkspace={mocks.onToggleWorkspace}
         onDeleteSession={mocks.onDeleteSession}
@@ -55,7 +55,7 @@ describe('ChatSessionHeaderActions', () => {
         sessionKey="draft-session"
         canDeleteSession={false}
         isDeletePending={false}
-        projectRoot={null}
+        currentPath={null}
         isWorkspaceOpen={false}
         onToggleWorkspace={mocks.onToggleWorkspace}
         onDeleteSession={mocks.onDeleteSession}
@@ -77,7 +77,7 @@ describe('ChatSessionHeaderActions', () => {
         sessionKey="session-codex"
         canDeleteSession
         isDeletePending={false}
-        projectRoot={null}
+        currentPath={null}
         metadata={{
           codex_thread_id: 'thread-123',
           runtime: 'codex',
@@ -106,7 +106,7 @@ describe('ChatSessionHeaderActions', () => {
         sessionKey="session-children"
         canDeleteSession
         isDeletePending={false}
-        projectRoot={null}
+        currentPath={null}
         isWorkspaceOpen={false}
         onToggleWorkspace={mocks.onToggleWorkspace}
         onDeleteSession={mocks.onDeleteSession}
@@ -126,7 +126,7 @@ describe('ChatSessionHeaderActions', () => {
         sessionKey="session-actions"
         canDeleteSession
         isDeletePending={false}
-        projectRoot={null}
+        currentPath={null}
         isWorkspaceOpen={false}
         onToggleWorkspace={mocks.onToggleWorkspace}
         onDeleteSession={mocks.onDeleteSession}
@@ -146,7 +146,7 @@ describe('ChatSessionHeaderActions', () => {
         sessionKey="session-actions"
         canDeleteSession
         isDeletePending={false}
-        projectRoot={null}
+        currentPath={null}
         isWorkspaceOpen={false}
         onToggleWorkspace={mocks.onToggleWorkspace}
         onDeleteSession={mocks.onDeleteSession}
@@ -169,7 +169,7 @@ describe('ChatSessionHeaderActions', () => {
         sessionKey="session-actions"
         canDeleteSession
         isDeletePending={false}
-        projectRoot={null}
+        currentPath={null}
         isWorkspaceOpen
         onToggleWorkspace={mocks.onToggleWorkspace}
         onDeleteSession={mocks.onDeleteSession}

package/src/features/chat/features/session/components/session-header/__tests__/chat-session-project-dialog.test.tsx

@@ -0,0 +1,47 @@
+import { render } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { ChatSessionProjectDialog } from "@/features/chat/features/session/components/session-header/chat-session-project-dialog";
+
+const pathPickerSpy = vi.fn((_props: unknown) => null);
+
+vi.mock("@/shared/components/path-picker/server-path-picker-dialog", () => ({
+  ServerPathPickerDialog: (props: unknown) => pathPickerSpy(props),
+}));
+
+describe("ChatSessionProjectDialog", () => {
+  it("uses the default workspace as the browse start and quick-access location", () => {
+    render(
+      <ChatSessionProjectDialog
+        open
+        currentProjectRoot={null}
+        defaultWorkspacePath="/tmp/default-workspace"
+        isSaving={false}
+        onOpenChange={() => undefined}
+        onSave={() => undefined}
+      />,
+    );
+
+    expect(pathPickerSpy).toHaveBeenCalledWith(expect.objectContaining({
+      currentPath: null,
+      defaultWorkspacePath: "/tmp/default-workspace",
+    }));
+  });
+
+  it("prefers an explicit project over the default workdir", () => {
+    render(
+      <ChatSessionProjectDialog
+        open
+        currentProjectRoot="/tmp/project"
+        defaultWorkspacePath="/tmp/default-workspace"
+        isSaving={false}
+        onOpenChange={() => undefined}
+        onSave={() => undefined}
+      />,
+    );
+
+    expect(pathPickerSpy).toHaveBeenLastCalledWith(expect.objectContaining({
+      currentPath: "/tmp/project",
+      defaultWorkspacePath: "/tmp/default-workspace",
+    }));
+  });
+});