@nextclaw/ui 0.11.21 → 0.11.22

package/src/components/chat/hooks/use-chat-session-project.test.tsx

@@ -0,0 +1,117 @@
+import { act, renderHook } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { toast } from 'sonner';
+import { useChatSessionProject } from '@/components/chat/hooks/use-chat-session-project';
+import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
+
+const mocks = vi.hoisted(() => ({
+  updateSession: vi.fn(),
+}));
+
+vi.mock('sonner', () => ({
+  toast: {
+    success: vi.fn(),
+  },
+}));
+
+vi.mock('@/components/chat/hooks/use-chat-session-update', () => ({
+  useChatSessionUpdate: () => mocks.updateSession,
+}));
+
+describe('useChatSessionProject', () => {
+  beforeEach(() => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        pendingProjectRoot: null,
+        pendingProjectRootSessionKey: null,
+      },
+    }));
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('stores the draft project root locally when the session does not exist yet', async () => {
+    const { result } = renderHook(() => useChatSessionProject());
+
+    await act(async () => {
+      await result.current({
+        sessionKey: 'draft-session-1',
+        projectRoot: '/tmp/project-alpha',
+        persistToServer: false,
+      });
+    });
+
+    expect(mocks.updateSession).not.toHaveBeenCalled();
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      pendingProjectRoot: '/tmp/project-alpha',
+      pendingProjectRootSessionKey: 'draft-session-1',
+    });
+    expect(toast.success).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps an explicit draft override when clearing the project root locally', async () => {
+    const { result } = renderHook(() => useChatSessionProject());
+
+    await act(async () => {
+      await result.current({
+        sessionKey: 'draft-session-1',
+        projectRoot: null,
+        persistToServer: false,
+      });
+    });
+
+    expect(mocks.updateSession).not.toHaveBeenCalled();
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: 'draft-session-1',
+    });
+    expect(toast.success).toHaveBeenCalledTimes(1);
+  });
+
+  it('persists to the server and mirrors the updated project override locally for an existing session', async () => {
+    const { result } = renderHook(() => useChatSessionProject());
+
+    await act(async () => {
+      await result.current({
+        sessionKey: 'session-1',
+        projectRoot: '/tmp/project-beta',
+        persistToServer: true,
+      });
+    });
+
+    expect(mocks.updateSession).toHaveBeenCalledWith({
+      sessionKey: 'session-1',
+      patch: { projectRoot: '/tmp/project-beta' },
+      successMessage: 'Project directory updated',
+    });
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      pendingProjectRoot: '/tmp/project-beta',
+      pendingProjectRootSessionKey: 'session-1',
+    });
+  });
+
+  it('persists clearing to the server and keeps the cleared override until session state catches up', async () => {
+    const { result } = renderHook(() => useChatSessionProject());
+
+    await act(async () => {
+      await result.current({
+        sessionKey: 'session-1',
+        projectRoot: null,
+        persistToServer: true,
+      });
+    });
+
+    expect(mocks.updateSession).toHaveBeenCalledWith({
+      sessionKey: 'session-1',
+      patch: { projectRoot: null },
+      successMessage: 'Project directory cleared',
+    });
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: 'session-1',
+    });
+  });
+});

package/src/components/chat/hooks/use-chat-session-project.ts

@@ -0,0 +1,40 @@
+import { toast } from 'sonner';
+import { t } from '@/lib/i18n';
+import { useChatSessionUpdate } from '@/components/chat/hooks/use-chat-session-update';
+import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
+
+type UpdateChatSessionProjectParams = {
+  sessionKey: string;
+  projectRoot: string | null;
+  persistToServer: boolean;
+};
+
+export function useChatSessionProject() {
+  const updateSession = useChatSessionUpdate();
+
+  return async (params: UpdateChatSessionProjectParams): Promise<void> => {
+    const successMessage = params.projectRoot
+      ? t('chatSessionProjectUpdated')
+      : t('chatSessionProjectCleared');
+
+    if (!params.persistToServer) {
+      useChatInputStore.getState().setSnapshot({
+        pendingProjectRoot: params.projectRoot,
+        pendingProjectRootSessionKey: params.sessionKey
+      });
+      toast.success(successMessage);
+      return;
+    }
+
+    await updateSession({
+      sessionKey: params.sessionKey,
+      patch: { projectRoot: params.projectRoot },
+      successMessage,
+    });
+
+    useChatInputStore.getState().setSnapshot({
+      pendingProjectRoot: params.projectRoot,
+      pendingProjectRootSessionKey: params.sessionKey,
+    });
+  };
+}

package/src/components/chat/{chat-session-label.service.ts → hooks/use-chat-session-update.ts}

@@ -1,24 +1,28 @@
 import { useQueryClient } from '@tanstack/react-query';
 import { toast } from 'sonner';
+import type { SessionPatchUpdate } from '@/api/types';
 import { upsertNcpSessionSummaryInQueryClient } from '@/api/ncp-session-query-cache';
 import { updateNcpSession } from '@/api/ncp-session';
 import { t } from '@/lib/i18n';
 
-type UpdateChatSessionLabelParams = {
+type UpdateChatSessionParams = {
   sessionKey: string;
-  label: string | null;
+  patch: SessionPatchUpdate;
+  successMessage?: string;
 };
 
-export function useChatSessionLabelService() {
+export function useChatSessionUpdate() {
   const queryClient = useQueryClient();
 
-  return async (params: UpdateChatSessionLabelParams): Promise<void> => {
+  return async (params: UpdateChatSessionParams): Promise<void> => {
     try {
-      const updated = await updateNcpSession(params.sessionKey, { label: params.label });
+      const updated = await updateNcpSession(params.sessionKey, params.patch);
       upsertNcpSessionSummaryInQueryClient(queryClient, updated);
-      toast.success(t('configSavedApplied'));
+      toast.success(params.successMessage ?? t('configSavedApplied'));
     } catch (error) {
-      toast.error(t('configSaveFailed') + ': ' + (error instanceof Error ? error.message : String(error)));
+      toast.error(
+        t('configSaveFailed') + ': ' + (error instanceof Error ? error.message : String(error)),
+      );
       throw error;
     }
   };

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

@@ -44,7 +44,11 @@ export class ChatSessionListManager {
         ? sessionType.trim()
         : defaultSessionType;
     this.streamActionsManager.resetStreamState();
-    useChatInputStore.getState().setSnapshot({ pendingSessionType: nextSessionType });
+    useChatInputStore.getState().setSnapshot({
+      pendingSessionType: nextSessionType,
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: null
+    });
     this.uiManager.goToChatRoot();
   };
 

package/src/components/chat/ncp/NcpChatPage.tsx

@@ -23,12 +23,14 @@ import { useChatSessionListStore } from '@/components/chat/stores/chat-session-l
 import { resolveSessionTypeLabel } from '@/components/chat/useChatSessionTypeState';
 import { useConfirmDialog } from '@/hooks/useConfirmDialog';
 import { normalizeRequestedSkills } from '@/lib/chat-runtime-utils';
+import { getSessionProjectName, normalizeSessionProjectRootValue } from '@/lib/session-project/session-project.utils';
 import { appClient } from '@/transport';
 
-function buildNcpSendMetadata(payload: {
+export function buildNcpSendMetadata(payload: {
   model?: string;
   thinkingLevel?: string;
   sessionType?: string;
+  projectRoot?: string | null;
   requestedSkills?: string[];
   composerNodes?: Parameters<typeof buildInlineSkillTokensFromComposer>[0];
 }): Record<string, unknown> {
@@ -44,9 +46,13 @@ function buildNcpSendMetadata(payload: {
   if (payload.sessionType?.trim()) {
     metadata.session_type = payload.sessionType.trim();
   }
+  const projectRoot = normalizeSessionProjectRootValue(payload.projectRoot);
+  if (projectRoot) {
+    metadata.project_root = projectRoot;
+  }
   const requestedSkills = normalizeRequestedSkills(payload.requestedSkills);
   if (requestedSkills.length > 0) {
-    metadata.requested_skills = requestedSkills;
+    metadata.requested_skill_refs = requestedSkills;
   }
   const inlineSkillTokens = payload.composerNodes
     ? buildInlineSkillTokensFromComposer(payload.composerNodes)
@@ -71,6 +77,8 @@ export function NcpChatPage({ view }: ChatPageProps) {
   const selectedSessionKey = useChatSessionListStore((state) => state.snapshot.selectedSessionKey);
   const selectedAgentId = useChatSessionListStore((state) => state.snapshot.selectedAgentId);
   const pendingSessionType = useChatInputStore((state) => state.snapshot.pendingSessionType);
+  const pendingProjectRoot = useChatInputStore((state) => state.snapshot.pendingProjectRoot);
+  const pendingProjectRootSessionKey = useChatInputStore((state) => state.snapshot.pendingProjectRootSessionKey);
   const currentSelectedModel = useChatInputStore((state) => state.snapshot.selectedModel);
   const { confirm, ConfirmDialog } = useConfirmDialog();
   const location = useLocation();
@@ -83,8 +91,11 @@ export function NcpChatPage({ view }: ChatPageProps) {
     () => parseSessionKeyFromRoute(routeSessionIdParam),
     [routeSessionIdParam]
   );
+  const sessionKey = selectedSessionKey ?? draftSessionId;
+  const hasSessionProjectRootOverride = pendingProjectRootSessionKey === sessionKey;
+  const sessionProjectRootOverride = hasSessionProjectRootOverride ? pendingProjectRoot : undefined;
   const {
-    installedSkillsQuery,
+    sessionSkillsQuery,
     isProviderStateResolved,
     modelOptions,
     sessionSummaries,
@@ -98,7 +109,8 @@ export function NcpChatPage({ view }: ChatPageProps) {
     sessionTypeUnavailableMessage
   } = useNcpChatPageData({
     query,
-    selectedSessionKey,
+    sessionKey,
+    projectRootOverride: sessionProjectRootOverride,
     currentSelectedModel,
     pendingSessionType,
     setPendingSessionType: presenter.chatInputManager.setPendingSessionType,
@@ -106,7 +118,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     setSelectedThinkingLevel: presenter.chatInputManager.setSelectedThinkingLevel
   });
 
-  const activeSessionId = selectedSessionKey ?? draftSessionId;
   const sessionSummariesRef = useRef(sessionSummaries);
   useEffect(() => {
     sessionSummariesRef.current = sessionSummaries;
@@ -141,7 +152,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
   }, []);
 
   const agent = useHydratedNcpAgent({
-    sessionId: activeSessionId,
+    sessionId: sessionKey,
     client: ncpClient,
     loadSeed
   });
@@ -158,6 +169,9 @@ export function NcpChatPage({ view }: ChatPageProps) {
     }
   }, [presenter, selectedSessionKey]);
 
+  const effectiveSessionProjectRoot = hasSessionProjectRootOverride ? pendingProjectRoot : selectedSession?.projectRoot ?? null;
+  const effectiveSessionProjectName = hasSessionProjectRootOverride ? getSessionProjectName(effectiveSessionProjectRoot) : selectedSession?.projectName ?? getSessionProjectName(effectiveSessionProjectRoot);
+
   const isSending = agent.isSending || agent.isRunning;
   const isAwaitingAssistantOutput = agent.isRunning;
   const canStopCurrentRun = agent.isRunning;
@@ -175,7 +189,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
 
       sessionStreamAttachInFlightRef.current = true;
       void ncpClient
-        .stream({ sessionId: activeSessionId })
+        .stream({ sessionId: sessionKey })
         .catch(() => undefined)
         .finally(() => {
           sessionStreamAttachInFlightRef.current = false;
@@ -185,24 +199,28 @@ export function NcpChatPage({ view }: ChatPageProps) {
     return appClient.subscribe((event) => {
       if (
         event.type === 'session.run-status' &&
-        event.payload.sessionKey === activeSessionId &&
+        event.payload.sessionKey === sessionKey &&
         event.payload.status === 'running'
       ) {
         attachRealtimeSessionStream();
       }
     });
-  }, [activeSessionId, agent.isHydrating, agent.isRunning, agent.isSending, ncpClient]);
+  }, [agent.isHydrating, agent.isRunning, agent.isSending, ncpClient, sessionKey]);
 
   useEffect(() => {
     presenter.chatStreamActionsManager.bind({
       sendMessage: async (payload) => {
-        if (payload.sessionKey !== activeSessionId) {
+        if (payload.sessionKey !== sessionKey) {
           return;
         }
         const metadata = buildNcpSendMetadata({
           model: payload.model,
           thinkingLevel: payload.thinkingLevel,
           sessionType: payload.sessionType,
+          projectRoot:
+            payload.sessionKey === pendingProjectRootSessionKey
+              ? pendingProjectRoot
+              : selectedSession?.projectRoot ?? null,
           requestedSkills: payload.requestedSkills,
           composerNodes: payload.composerNodes
         });
@@ -238,7 +256,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
         await agent.abort();
       },
       resumeRun: async (run: ResumeRunParams) => {
-        if (run.sessionKey !== activeSessionId) {
+        if (run.sessionKey !== sessionKey) {
           return;
         }
         await agent.streamRun();
@@ -248,7 +266,24 @@ export function NcpChatPage({ view }: ChatPageProps) {
       },
       applyHistoryMessages: () => {}
     });
-  }, [activeSessionId, agent, presenter]);
+  }, [
+    agent,
+    pendingProjectRoot,
+    pendingProjectRootSessionKey,
+    presenter,
+    selectedSession?.projectRoot,
+    sessionKey
+  ]);
+
+  useEffect(() => {
+    if (!selectedSession || pendingProjectRootSessionKey !== selectedSession.key || (selectedSession.projectRoot ?? null) !== pendingProjectRoot) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: null
+    });
+  }, [pendingProjectRoot, pendingProjectRootSessionKey, selectedSession]);
 
   useChatSessionSync({
     view,
@@ -293,7 +328,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
       canEditSessionType,
       sessionTypeUnavailable,
       skillRecords,
-      isSkillsLoading: installedSkillsQuery.isLoading
+      isSkillsLoading: sessionSkillsQuery.isLoading
     });
     presenter.chatThreadManager.syncSnapshot({
       isProviderStateResolved,
@@ -301,8 +336,10 @@ export function NcpChatPage({ view }: ChatPageProps) {
       sessionTypeUnavailable,
       sessionTypeUnavailableMessage,
       sessionTypeLabel: currentSessionTypeLabel,
-      selectedSessionKey,
+      sessionKey,
       sessionDisplayName: currentSessionDisplayName,
+      sessionProjectRoot: effectiveSessionProjectRoot,
+      sessionProjectName: effectiveSessionProjectName,
       canDeleteSession: Boolean(selectedSession),
       threadRef,
       isHistoryLoading: agent.isHydrating,
@@ -317,16 +354,17 @@ export function NcpChatPage({ view }: ChatPageProps) {
     currentSessionDisplayName,
     currentSessionTypeLabel,
     defaultSessionType,
-    installedSkillsQuery.isLoading,
+    sessionSkillsQuery.isLoading,
     isAwaitingAssistantOutput,
     isProviderStateResolved,
     isSending,
     lastSendError,
-    modelOptions.length,
     modelOptions,
     presenter,
+    effectiveSessionProjectName,
+    effectiveSessionProjectRoot,
     selectedSession,
-    selectedSessionKey,
+    sessionKey,
     selectedSessionType,
     sessionTypeOptions,
     sessionTypeUnavailable,

package/src/components/chat/ncp/ncp-chat-page-data.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import { buildNcpSendMetadata } from '@/components/chat/ncp/NcpChatPage';
 import { filterModelOptionsBySessionType } from '@/components/chat/ncp/ncp-chat-page-data';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 
@@ -42,3 +43,35 @@ describe('filterModelOptionsBySessionType', () => {
     ).toEqual(modelOptions);
   });
 });
+
+describe('buildNcpSendMetadata', () => {
+  it('includes the project root in the first-message metadata when present', () => {
+    expect(
+      buildNcpSendMetadata({
+        sessionType: 'codex',
+        projectRoot: ' /tmp/project-alpha ',
+      }),
+    ).toMatchObject({
+      session_type: 'codex',
+      project_root: '/tmp/project-alpha',
+    });
+  });
+
+  it('omits project_root when the input is blank', () => {
+    expect(
+      buildNcpSendMetadata({
+        projectRoot: '   ',
+      }),
+    ).not.toHaveProperty('project_root');
+  });
+
+  it('sends requested skill refs instead of legacy requested skill names', () => {
+    expect(
+      buildNcpSendMetadata({
+        requestedSkills: ['project:/tmp/project-alpha/.agents/skills/review'],
+      }),
+    ).toMatchObject({
+      requested_skill_refs: ['project:/tmp/project-alpha/.agents/skills/review'],
+    });
+  });
+});

package/src/components/chat/ncp/ncp-chat-page-data.ts

@@ -14,15 +14,16 @@ import {
 import {
   useConfig,
   useConfigMeta,
+  useNcpSessionSkills,
   useNcpSessions
 } from '@/hooks/useConfig';
 import { useNcpChatSessionTypes } from '@/hooks/use-ncp-chat-session-types';
-import { useMarketplaceInstalled } from '@/hooks/useMarketplace';
 import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/lib/provider-models';
 
 type UseNcpChatPageDataParams = {
   query: string;
-  selectedSessionKey: string | null;
+  sessionKey: string;
+  projectRootOverride?: string | null;
   currentSelectedModel: string;
   pendingSessionType: string;
   setPendingSessionType: Dispatch<SetStateAction<string>>;
@@ -51,7 +52,12 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   const configMetaQuery = useConfigMeta();
   const sessionsQuery = useNcpSessions({ limit: 200 });
   const sessionTypesQuery = useNcpChatSessionTypes();
-  const installedSkillsQuery = useMarketplaceInstalled('skill');
+  const sessionSkillsQuery = useNcpSessionSkills({
+    sessionId: params.sessionKey,
+    ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
+      ? { projectRoot: params.projectRootOverride ?? null }
+      : {})
+  });
   const isProviderStateResolved =
     (configQuery.isFetched || configQuery.isSuccess) &&
     (configMetaQuery.isFetched || configMetaQuery.isSuccess);
@@ -101,16 +107,16 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
     [allSessions, params.query]
   );
   const selectedSession = useMemo(
-    () => allSessions.find((session) => session.key === params.selectedSessionKey) ?? null,
-    [allSessions, params.selectedSessionKey]
+    () => allSessions.find((session) => session.key === params.sessionKey) ?? null,
+    [allSessions, params.sessionKey]
   );
   const skillRecords = useMemo(
-    () => installedSkillsQuery.data?.records ?? [],
-    [installedSkillsQuery.data?.records]
+    () => sessionSkillsQuery.data?.records ?? [],
+    [sessionSkillsQuery.data?.records]
   );
   const sessionTypeState = useChatSessionTypeState({
     selectedSession,
-    selectedSessionKey: params.selectedSessionKey,
+    selectedSessionKey: params.sessionKey,
     pendingSessionType: params.pendingSessionType,
     setPendingSessionType: params.setPendingSessionType,
     sessionTypesData: sessionTypesQuery.data
@@ -127,10 +133,10 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
     () =>
       resolveRecentSessionPreferredModel({
         sessions: allSessions,
-        selectedSessionKey: params.selectedSessionKey,
+        selectedSessionKey: params.sessionKey,
         sessionType: sessionTypeState.selectedSessionType
       }),
-    [allSessions, params.selectedSessionKey, sessionTypeState.selectedSessionType]
+    [allSessions, params.sessionKey, sessionTypeState.selectedSessionType]
   );
   const currentModelOption = useMemo(
     () => filteredModelOptions.find((option) => option.value === params.currentSelectedModel),
@@ -148,15 +154,15 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
     () =>
       resolveRecentSessionPreferredThinking({
         sessions: allSessions,
-        selectedSessionKey: params.selectedSessionKey,
+        selectedSessionKey: params.sessionKey,
         sessionType: sessionTypeState.selectedSessionType
       }),
-    [allSessions, params.selectedSessionKey, sessionTypeState.selectedSessionType]
+    [allSessions, params.sessionKey, sessionTypeState.selectedSessionType]
   );
 
   useSyncSelectedModel({
     modelOptions: filteredModelOptions,
-    selectedSessionKey: params.selectedSessionKey,
+    selectedSessionKey: params.sessionKey,
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredModel: selectedSession?.preferredModel,
     fallbackPreferredModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? recentSessionPreferredModel,
@@ -165,7 +171,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   });
   useSyncSelectedThinking({
     supportedThinkingLevels,
-    selectedSessionKey: params.selectedSessionKey,
+    selectedSessionKey: params.sessionKey,
     selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
     fallbackPreferredThinking: recentSessionPreferredThinking ?? null,
@@ -178,7 +184,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
     configMetaQuery,
     sessionsQuery,
     sessionTypesQuery,
-    installedSkillsQuery,
+    sessionSkillsQuery,
     isProviderStateResolved,
     modelOptions: filteredModelOptions,
     sessionSummaries,

package/src/components/chat/ncp/ncp-session-adapter.test.ts

@@ -24,6 +24,7 @@ describe('adaptNcpSessionSummary', () => {
           label: 'NCP Planning Thread',
           model: 'openai/gpt-5',
           preferred_thinking: 'medium',
+          project_root: '/Users/demo/workspace/project-alpha',
           session_type: 'native'
         }
       })
@@ -34,6 +35,8 @@ describe('adaptNcpSessionSummary', () => {
       label: 'NCP Planning Thread',
       preferredModel: 'openai/gpt-5',
       preferredThinking: 'medium',
+      projectRoot: '/Users/demo/workspace/project-alpha',
+      projectName: 'project-alpha',
       sessionType: 'native',
       sessionTypeMutable: false,
       messageCount: 3

package/src/components/chat/ncp/ncp-session-adapter.ts

@@ -1,6 +1,10 @@
 import { ToolInvocationStatus, type UIMessage } from '@nextclaw/agent-chat';
 import type { NcpMessagePart } from '@nextclaw/ncp';
 import type { NcpMessageView, NcpSessionSummaryView, SessionEntryView, ThinkingLevel } from '@/api/types';
+import {
+  getSessionProjectName,
+  normalizeSessionProjectRootValue,
+} from '@/lib/session-project/session-project.utils';
 
 const THINKING_LEVEL_SET = new Set<string>(['off', 'minimal', 'low', 'medium', 'high', 'adaptive', 'xhigh']);
 
@@ -68,6 +72,14 @@ function readNcpSessionLabel(summary: NcpSessionSummaryView): string | null {
   return readOptionalString(metadata.label);
 }
 
+function readNcpSessionProjectRoot(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return normalizeSessionProjectRootValue(metadata.project_root ?? metadata.projectRoot);
+}
+
 function readNcpSessionType(summary: NcpSessionSummaryView): string {
   const metadata = readMetadata(summary);
   if (!metadata) {
@@ -207,6 +219,8 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
   const label = readNcpSessionLabel(summary);
   const preferredModel = readNcpSessionPreferredModel(summary);
   const preferredThinking = readNcpSessionPreferredThinking(summary);
+  const projectRoot = readNcpSessionProjectRoot(summary);
+  const projectName = getSessionProjectName(projectRoot);
   const context = parseSessionContext(summary.sessionId);
   return {
     key: summary.sessionId,
@@ -216,6 +230,8 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
     ...context,
     ...(preferredModel ? { preferredModel } : {}),
     ...(preferredThinking ? { preferredThinking } : {}),
+    ...(projectRoot ? { projectRoot } : {}),
+    ...(projectName ? { projectName } : {}),
     sessionType: readNcpSessionType(summary),
     sessionTypeMutable: false,
     messageCount: summary.messageCount

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

@@ -0,0 +1,63 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatSessionHeaderActions } from '@/components/chat/session-header/chat-session-header-actions';
+
+const mocks = vi.hoisted(() => ({
+  updateSessionProject: vi.fn(),
+  onDeleteSession: vi.fn(),
+}));
+
+vi.mock('@/components/chat/hooks/use-chat-session-project', () => ({
+  useChatSessionProject: () => mocks.updateSessionProject,
+}));
+
+vi.mock('@/components/chat/session-header/chat-session-project-dialog', () => ({
+  ChatSessionProjectDialog: () => null,
+}));
+
+describe('ChatSessionHeaderActions', () => {
+  beforeEach(() => {
+    mocks.updateSessionProject.mockReset();
+    mocks.onDeleteSession.mockReset();
+  });
+
+  it('keeps only the set-project action in the more-actions menu when a project is already attached', async () => {
+    const user = userEvent.setup();
+
+    render(
+      <ChatSessionHeaderActions
+        sessionKey="session-1"
+        canDeleteSession
+        isDeletePending={false}
+        projectRoot="/tmp/project-alpha"
+        onDeleteSession={mocks.onDeleteSession}
+      />
+    );
+
+    await user.click(screen.getByRole('button', { name: 'More actions' }));
+
+    expect(screen.getByText('Set Project Directory')).toBeTruthy();
+    expect(screen.queryByText('Clear Project Directory')).toBeNull();
+    expect(screen.getByText('Delete Session')).toBeTruthy();
+  });
+
+  it('keeps the set-project entry in the more-actions menu when no project is attached', async () => {
+    const user = userEvent.setup();
+
+    render(
+      <ChatSessionHeaderActions
+        sessionKey="draft-session"
+        canDeleteSession={false}
+        isDeletePending={false}
+        projectRoot={null}
+        onDeleteSession={mocks.onDeleteSession}
+      />
+    );
+
+    await user.click(screen.getByRole('button', { name: 'More actions' }));
+
+    expect(screen.getByText('Set Project Directory')).toBeTruthy();
+    expect(screen.queryByText('Clear Project Directory')).toBeNull();
+  });
+});