@nextclaw/ui 0.11.21 → 0.11.23

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

@@ -1,34 +1,59 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { NcpHttpAgentClientEndpoint } from '@nextclaw/ncp-http-agent-client';
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type MutableRefObject,
+} from "react";
+import { NcpHttpAgentClientEndpoint } from "@nextclaw/ncp-http-agent-client";
 import {
   buildNcpRequestEnvelope,
   useHydratedNcpAgent,
-  type NcpConversationSeed
-} from '@nextclaw/ncp-react';
-import { useLocation, useNavigate, useParams } from 'react-router-dom';
-import { API_BASE } from '@/api/api-base';
-import { fetchNcpSessionMessages } from '@/api/ncp-session';
-import { ChatPageLayout, type ChatPageProps, useChatSessionSync } from '@/components/chat/chat-page-shell';
-import { sessionDisplayName } from '@/components/chat/chat-session-display';
-import { buildInlineSkillTokensFromComposer, CHAT_UI_INLINE_TOKENS_METADATA_KEY } from '@/components/chat/chat-inline-token.utils';
-import { createNcpAppClientFetch } from '@/components/chat/ncp/ncp-app-client-fetch';
-import { parseSessionKeyFromRoute, resolveAgentIdFromSessionKey } from '@/components/chat/chat-session-route';
-import { useNcpChatPageData } from '@/components/chat/ncp/ncp-chat-page-data';
-import { NcpChatPresenter } from '@/components/chat/ncp/ncp-chat.presenter';
-import { createNcpSessionId } from '@/components/chat/ncp/ncp-session-adapter';
-import { ChatPresenterProvider } from '@/components/chat/presenter/chat-presenter-context';
-import type { ResumeRunParams } from '@/components/chat/chat-stream/types';
-import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
-import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
-import { resolveSessionTypeLabel } from '@/components/chat/useChatSessionTypeState';
-import { useConfirmDialog } from '@/hooks/useConfirmDialog';
-import { normalizeRequestedSkills } from '@/lib/chat-runtime-utils';
-import { appClient } from '@/transport';
+  type NcpConversationSeed,
+  type NcpConversationSeedLoader,
+} from "@nextclaw/ncp-react";
+import { useLocation, useNavigate, useParams } from "react-router-dom";
+import { API_BASE } from "@/api/api-base";
+import { fetchNcpSessionMessages } from "@/api/ncp-session";
+import {
+  ChatPageLayout,
+  type ChatPageProps,
+  useChatSessionSync,
+} from "@/components/chat/chat-page-shell";
+import { sessionDisplayName } from "@/components/chat/chat-session-display";
+import {
+  buildInlineSkillTokensFromComposer,
+  CHAT_UI_INLINE_TOKENS_METADATA_KEY,
+} from "@/components/chat/chat-inline-token.utils";
+import { createNcpAppClientFetch } from "@/components/chat/ncp/ncp-app-client-fetch";
+import {
+  parseSessionKeyFromRoute,
+  resolveAgentIdFromSessionKey,
+} from "@/components/chat/chat-session-route";
+import { useNcpChatPageData } from "@/components/chat/ncp/ncp-chat-page-data";
+import { NcpChatPresenter } from "@/components/chat/ncp/ncp-chat.presenter";
+import {
+  adaptNcpSessionSummary,
+  createNcpSessionId,
+} from "@/components/chat/ncp/ncp-session-adapter";
+import { ChatPresenterProvider } from "@/components/chat/presenter/chat-presenter-context";
+import type { ResumeRunParams } from "@/components/chat/chat-stream/types";
+import { useChatInputStore } from "@/components/chat/stores/chat-input.store";
+import { useChatSessionListStore } from "@/components/chat/stores/chat-session-list.store";
+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";
 
-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 +69,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)
@@ -61,30 +90,91 @@ function isMissingNcpSessionError(error: unknown): boolean {
   if (!(error instanceof Error)) {
     return false;
   }
-  return error.message.includes('ncp session not found:');
+  return error.message.includes("ncp session not found:");
+}
+
+type NcpSeedSessionSummary = {
+  sessionId: string;
+  status?: string;
+};
+
+function useNcpConversationSeedLoader<T extends NcpSeedSessionSummary>(
+  sessionSummariesRef: MutableRefObject<readonly T[]>,
+): NcpConversationSeedLoader {
+  return useCallback(
+    async (
+      sessionId: string,
+      signal: AbortSignal,
+    ): Promise<NcpConversationSeed> => {
+      signal.throwIfAborted();
+      let history: Awaited<ReturnType<typeof fetchNcpSessionMessages>> | null =
+        null;
+      try {
+        history = await fetchNcpSessionMessages(sessionId, 300);
+      } catch (error) {
+        if (!isMissingNcpSessionError(error)) {
+          throw error;
+        }
+      }
+      signal.throwIfAborted();
+
+      const sessionSummary =
+        sessionSummariesRef.current.find(
+          (item) => item.sessionId === sessionId,
+        ) ?? null;
+      return {
+        messages: history?.messages ?? [],
+        status: sessionSummary?.status === "running" ? "running" : "idle",
+      };
+    },
+    [sessionSummariesRef],
+  );
 }
 
 export function NcpChatPage({ view }: ChatPageProps) {
   const [presenter] = useState(() => new NcpChatPresenter());
-  const [draftSessionId, setDraftSessionId] = useState(() => createNcpSessionId());
+  const [draftSessionId, setDraftSessionId] = useState(() =>
+    createNcpSessionId(),
+  );
   const query = useChatSessionListStore((state) => state.snapshot.query);
-  const selectedSessionKey = useChatSessionListStore((state) => state.snapshot.selectedSessionKey);
-  const selectedAgentId = useChatSessionListStore((state) => state.snapshot.selectedAgentId);
-  const pendingSessionType = useChatInputStore((state) => state.snapshot.pendingSessionType);
-  const currentSelectedModel = useChatInputStore((state) => state.snapshot.selectedModel);
+  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();
   const navigate = useNavigate();
-  const { sessionId: routeSessionIdParam } = useParams<{ sessionId?: string }>();
+  const { sessionId: routeSessionIdParam } = useParams<{
+    sessionId?: string;
+  }>();
   const threadRef = useRef<HTMLDivElement | null>(null);
   const selectedSessionKeyRef = useRef<string | null>(selectedSessionKey);
-  const sessionStreamAttachInFlightRef = useRef(false);
   const routeSessionKey = useMemo(
     () => parseSessionKeyFromRoute(routeSessionIdParam),
-    [routeSessionIdParam]
+    [routeSessionIdParam],
   );
+  const sessionKey = selectedSessionKey ?? draftSessionId;
+  const hasSessionProjectRootOverride =
+    pendingProjectRootSessionKey === sessionKey;
+  const sessionProjectRootOverride = hasSessionProjectRootOverride
+    ? pendingProjectRoot
+    : undefined;
   const {
-    installedSkillsQuery,
+    sessionSkillsQuery,
     isProviderStateResolved,
     modelOptions,
     sessionSummaries,
@@ -95,18 +185,19 @@ export function NcpChatPage({ view }: ChatPageProps) {
     selectedSessionType,
     canEditSessionType,
     sessionTypeUnavailable,
-    sessionTypeUnavailableMessage
+    sessionTypeUnavailableMessage,
   } = useNcpChatPageData({
     query,
-    selectedSessionKey,
+    sessionKey,
+    projectRootOverride: sessionProjectRootOverride,
     currentSelectedModel,
     pendingSessionType,
     setPendingSessionType: presenter.chatInputManager.setPendingSessionType,
     setSelectedModel: presenter.chatInputManager.setSelectedModel,
-    setSelectedThinkingLevel: presenter.chatInputManager.setSelectedThinkingLevel
+    setSelectedThinkingLevel:
+      presenter.chatInputManager.setSelectedThinkingLevel,
   });
 
-  const activeSessionId = selectedSessionKey ?? draftSessionId;
   const sessionSummariesRef = useRef(sessionSummaries);
   useEffect(() => {
     sessionSummariesRef.current = sessionSummaries;
@@ -115,35 +206,18 @@ export function NcpChatPage({ view }: ChatPageProps) {
   const [ncpClient] = useState(
     () =>
       new NcpHttpAgentClientEndpoint({
-      baseUrl: API_BASE,
-      basePath: '/api/ncp/agent',
-      fetchImpl: createNcpAppClientFetch()
-      })
+        baseUrl: API_BASE,
+        basePath: "/api/ncp/agent",
+        fetchImpl: createNcpAppClientFetch(),
+      }),
   );
 
-  const loadSeed = useCallback(async (sessionId: string, signal: AbortSignal): Promise<NcpConversationSeed> => {
-    signal.throwIfAborted();
-    let history: Awaited<ReturnType<typeof fetchNcpSessionMessages>> | null = null;
-    try {
-      history = await fetchNcpSessionMessages(sessionId, 300);
-    } catch (error) {
-      if (!isMissingNcpSessionError(error)) {
-        throw error;
-      }
-    }
-    signal.throwIfAborted();
-
-    const sessionSummary = sessionSummariesRef.current.find((item) => item.sessionId === sessionId) ?? null;
-    return {
-      messages: history?.messages ?? [],
-      status: sessionSummary?.status === 'running' ? 'running' : 'idle'
-    };
-  }, []);
+  const loadSeed = useNcpConversationSeedLoader(sessionSummariesRef);
 
   const agent = useHydratedNcpAgent({
-    sessionId: activeSessionId,
+    sessionId: sessionKey,
     client: ncpClient,
-    loadSeed
+    loadSeed,
   });
 
   useEffect(() => {
@@ -158,60 +232,45 @@ export function NcpChatPage({ view }: ChatPageProps) {
     }
   }, [presenter, selectedSessionKey]);
 
+  const effectiveSessionProjectRoot = hasSessionProjectRootOverride
+    ? pendingProjectRoot
+    : (selectedSession?.projectRoot ?? null);
+  const effectiveSessionProjectName = hasSessionProjectRootOverride
+    ? getSessionProjectName(effectiveSessionProjectRoot)
+    : (selectedSession?.projectName ??
+      getSessionProjectName(effectiveSessionProjectRoot));
+  const parentSessionId = selectedSession?.parentSessionId ?? null;
+
   const isSending = agent.isSending || agent.isRunning;
   const isAwaitingAssistantOutput = agent.isRunning;
   const canStopCurrentRun = agent.isRunning;
-  const stopDisabledReason = agent.isRunning ? null : '__preparing__';
-  const lastSendError = agent.hydrateError?.message ?? agent.snapshot.error?.message ?? null;
-
-  useEffect(() => {
-    const attachRealtimeSessionStream = () => {
-      if (sessionStreamAttachInFlightRef.current) {
-        return;
-      }
-      if (agent.isHydrating || agent.isRunning || agent.isSending) {
-        return;
-      }
-
-      sessionStreamAttachInFlightRef.current = true;
-      void ncpClient
-        .stream({ sessionId: activeSessionId })
-        .catch(() => undefined)
-        .finally(() => {
-          sessionStreamAttachInFlightRef.current = false;
-        });
-    };
-
-    return appClient.subscribe((event) => {
-      if (
-        event.type === 'session.run-status' &&
-        event.payload.sessionKey === activeSessionId &&
-        event.payload.status === 'running'
-      ) {
-        attachRealtimeSessionStream();
-      }
-    });
-  }, [activeSessionId, agent.isHydrating, agent.isRunning, agent.isSending, ncpClient]);
+  const stopDisabledReason = agent.isRunning ? null : "__preparing__";
+  const lastSendError =
+    agent.hydrateError?.message ?? agent.snapshot.error?.message ?? null;
 
   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
+          composerNodes: payload.composerNodes,
         });
         const envelope = buildNcpRequestEnvelope({
           sessionId: payload.sessionKey,
           text: payload.message,
           attachments: payload.attachments,
           parts: payload.parts,
-          metadata
+          metadata,
         });
         if (!envelope) {
           return;
@@ -223,11 +282,13 @@ export function NcpChatPage({ view }: ChatPageProps) {
             if (payload.composerNodes && payload.composerNodes.length > 0) {
               presenter.chatInputManager.restoreComposerState?.(
                 payload.composerNodes,
-                payload.attachments ?? []
+                payload.attachments ?? [],
               );
             } else {
               presenter.chatInputManager.setDraft((currentDraft) =>
-                currentDraft.trim().length === 0 ? payload.message : currentDraft
+                currentDraft.trim().length === 0
+                  ? payload.message
+                  : currentDraft,
               );
             }
           }
@@ -238,7 +299,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();
@@ -246,36 +307,70 @@ export function NcpChatPage({ view }: ChatPageProps) {
       resetStreamState: () => {
         selectedSessionKeyRef.current = null;
       },
-      applyHistoryMessages: () => {}
+      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,
     routeSessionKey,
     selectedSessionKey,
     selectedAgentId,
-    setSelectedSessionKey: presenter.chatSessionListManager.setSelectedSessionKey,
+    setSelectedSessionKey:
+      presenter.chatSessionListManager.setSelectedSessionKey,
     setSelectedAgentId: presenter.chatSessionListManager.setSelectedAgentId,
     selectedSessionKeyRef,
     resetStreamState: presenter.chatStreamActionsManager.resetStreamState,
-    resolveAgentIdFromSessionKey
+    resolveAgentIdFromSessionKey,
   });
 
   useEffect(() => {
     presenter.chatUiManager.syncState({
-      pathname: location.pathname
+      pathname: location.pathname,
     });
     presenter.chatUiManager.bindActions({
       navigate,
-      confirm
+      confirm,
     });
   }, [confirm, location.pathname, navigate, presenter]);
 
-  const currentSessionDisplayName = selectedSession ? sessionDisplayName(selectedSession) : undefined;
+  const currentSessionDisplayName = selectedSession
+    ? sessionDisplayName(selectedSession)
+    : undefined;
+  const parentSession = useMemo(() => {
+    if (!parentSessionId) {
+      return null;
+    }
+    const parentSummary =
+      sessionSummaries.find(
+        (summary) => summary.sessionId === parentSessionId,
+      ) ?? null;
+    return parentSummary ? adaptNcpSessionSummary(parentSummary) : null;
+  }, [parentSessionId, sessionSummaries]);
   const currentSessionTypeLabel =
-    sessionTypeOptions.find((option) => option.value === selectedSessionType)?.label ??
-    resolveSessionTypeLabel(selectedSessionType);
+    sessionTypeOptions.find((option) => option.value === selectedSessionType)
+      ?.label ?? resolveSessionTypeLabel(selectedSessionType);
 
   useEffect(() => {
     presenter.chatInputManager.syncSnapshot({
@@ -293,7 +388,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
       canEditSessionType,
       sessionTypeUnavailable,
       skillRecords,
-      isSkillsLoading: installedSkillsQuery.isLoading
+      isSkillsLoading: sessionSkillsQuery.isLoading,
     });
     presenter.chatThreadManager.syncSnapshot({
       isProviderStateResolved,
@@ -301,14 +396,20 @@ export function NcpChatPage({ view }: ChatPageProps) {
       sessionTypeUnavailable,
       sessionTypeUnavailableMessage,
       sessionTypeLabel: currentSessionTypeLabel,
-      selectedSessionKey,
+      sessionKey,
       sessionDisplayName: currentSessionDisplayName,
+      sessionProjectRoot: effectiveSessionProjectRoot,
+      sessionProjectName: effectiveSessionProjectName,
       canDeleteSession: Boolean(selectedSession),
       threadRef,
       isHistoryLoading: agent.isHydrating,
       messages: agent.visibleMessages,
       isSending,
-      isAwaitingAssistantOutput
+      isAwaitingAssistantOutput,
+      parentSessionKey: parentSession?.key ?? null,
+      parentSessionLabel: parentSession
+        ? sessionDisplayName(parentSession)
+        : null,
     });
   }, [
     agent.isHydrating,
@@ -317,16 +418,18 @@ export function NcpChatPage({ view }: ChatPageProps) {
     currentSessionDisplayName,
     currentSessionTypeLabel,
     defaultSessionType,
-    installedSkillsQuery.isLoading,
+    sessionSkillsQuery.isLoading,
     isAwaitingAssistantOutput,
     isProviderStateResolved,
     isSending,
     lastSendError,
-    modelOptions.length,
     modelOptions,
+    parentSession,
     presenter,
+    effectiveSessionProjectName,
+    effectiveSessionProjectRoot,
     selectedSession,
-    selectedSessionKey,
+    sessionKey,
     selectedSessionType,
     sessionTypeOptions,
     sessionTypeUnavailable,
@@ -334,7 +437,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
     skillRecords,
     stopDisabledReason,
     threadRef,
-    agent.visibleMessages
+    agent.visibleMessages,
   ]);
 
   return (

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,