@nextclaw/ui 0.20.1 → 0.20.3

package/src/features/chat/components/layout/__tests__/chat-sidebar-session-area.test.tsx

@@ -2,7 +2,7 @@ import { fireEvent, render, screen } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
 import { ChatSidebarSessionArea } from "@/features/chat/components/layout/chat-sidebar-desktop-layout";
 
-function renderSessionArea(isProjectFirstView: boolean) {
+function renderSessionArea(isProjectFirstView: boolean, onScrollNearEnd = vi.fn()) {
   const onAddProject = vi.fn();
   const onSelectMode = vi.fn();
 
@@ -14,14 +14,16 @@ function renderSessionArea(isProjectFirstView: boolean) {
       isLoading={false}
       isProjectFirstView={isProjectFirstView}
       onAddProject={onAddProject}
+      onScrollNearEnd={onScrollNearEnd}
       onSelectMode={onSelectMode}
       projectGroups={[]}
+      projectCronJobCountByRoot={new Map()}
       renderSessionItem={() => <></>}
       sessionTypeOptions={[]}
     />,
   );
 
-  return { onAddProject, onSelectMode };
+  return { onAddProject, onScrollNearEnd, onSelectMode };
 }
 
 describe("ChatSidebarSessionArea", () => {
@@ -59,7 +61,9 @@ describe("ChatSidebarSessionArea", () => {
 
   it("uses a folder-plus icon for the add-project action", () => {
     const { onAddProject } = renderSessionArea(true);
-    const addProjectButton = screen.getByRole("button", { name: "Add Project" });
+    const addProjectButton = screen.getByRole("button", {
+      name: "Add Project",
+    });
     const modeIndicator = screen
       .getByRole("group", { name: "Session list view" })
       .querySelector("span[aria-hidden='true']");
@@ -72,12 +76,29 @@ describe("ChatSidebarSessionArea", () => {
     expect(addProjectButton.className).toContain("hover:bg-gray-200/60");
     expect(modeIndicator?.className).toContain("translate-x-full");
     expect(modeIndicator?.className).toContain("motion-reduce:transition-none");
-    expect(screen.getByRole("button", { name: "Project" }).getAttribute("aria-pressed")).toBe(
-      "true",
+    expect(
+      screen
+        .getByRole("button", { name: "Project" })
+        .getAttribute("aria-pressed"),
+    ).toBe("true");
+    expect(modeIndicator?.parentElement?.previousElementSibling).toBe(
+      addProjectButton,
     );
-    expect(modeIndicator?.parentElement?.previousElementSibling).toBe(addProjectButton);
     fireEvent.click(addProjectButton);
 
     expect(onAddProject).toHaveBeenCalledOnce();
   });
+
+  it("requests the next page before scrolling reaches the end", () => {
+    const { onScrollNearEnd } = renderSessionArea(false);
+    const scroller = document.querySelector(".overflow-y-auto") as HTMLDivElement;
+    Object.defineProperties(scroller, {
+      scrollHeight: { value: 2_000 },
+      clientHeight: { value: 500 },
+    });
+
+    fireEvent.scroll(scroller, { target: { scrollTop: 1_000 } });
+
+    expect(onScrollNearEnd).toHaveBeenCalledOnce();
+  });
 });

package/src/features/chat/components/layout/__tests__/chat-sidebar.test.tsx

@@ -18,7 +18,6 @@ const mocks = vi.hoisted(() => ({
   setQuery: vi.fn(),
   setListMode: vi.fn(),
   selectSession: vi.fn(),
-  openChildSessionPanel: vi.fn(),
   docOpen: vi.fn(),
   setLanguage: vi.fn(),
   setTheme: vi.fn(),
@@ -49,7 +48,12 @@ vi.mock("@/shared/hooks/use-projects", () => ({
     isPending: false,
     error: null,
   }),
-  useAddExistingProject: () => ({ mutateAsync: vi.fn(), reset: vi.fn(), isPending: false, error: null }),
+  useAddExistingProject: () => ({
+    mutateAsync: vi.fn(),
+    reset: vi.fn(),
+    isPending: false,
+    error: null,
+  }),
 }));
 function sidebarElement(variant?: "desktop" | "mobile") {
   const queryClient = new QueryClient({
@@ -82,7 +86,10 @@ function expectCodexSelectedInSessionTypeMenu() {
   ).toBe("true");
 }
 function expectSessionCreated(sessionType: string, projectRoot?: string) {
-  expect(mocks.createSession).toHaveBeenCalledWith({ projectRoot, sessionType });
+  expect(mocks.createSession).toHaveBeenCalledWith({
+    projectRoot,
+    sessionType,
+  });
 }
 
 vi.mock("@/features/chat/components/providers/chat-presenter.provider", () => ({
@@ -106,9 +113,7 @@ vi.mock("@/features/chat/components/providers/chat-presenter.provider", () => ({
               .markSessionRead(sessionKey, readAt)
           : undefined,
     },
-    chatThreadManager: {
-      openChildSessionPanel: mocks.openChildSessionPanel,
-    },
+    chatThreadManager: {},
   }),
 }));
 
@@ -145,6 +150,7 @@ vi.mock(
 
 vi.mock("@/features/chat/features/ncp/hooks/use-ncp-session-list-view", () => ({
   useNcpSessionListView: () => ({
+    allItems: mocks.sessionItems,
     isLoading: mocks.isLoading,
     items: mocks.sessionItems,
   }),
@@ -196,7 +202,6 @@ function resetSidebarTestState() {
   mocks.setQuery.mockReset();
   mocks.setListMode.mockReset();
   mocks.selectSession.mockReset();
-  mocks.openChildSessionPanel.mockReset();
   mocks.docOpen.mockReset();
   mocks.setLanguage.mockReset();
   mocks.setTheme.mockReset();
@@ -284,9 +289,9 @@ describe("ChatSidebar create and list basics", () => {
   it("keeps the desktop brand row compact with symmetric vertical padding", () => {
     renderSidebar();
 
-    expect(
-      screen.getByTestId("brand-header").parentElement?.className,
-    ).toMatch(/(?:^|\s)py-2(?:\s|$)/);
+    expect(screen.getByTestId("brand-header").parentElement?.className).toMatch(
+      /(?:^|\s)py-2(?:\s|$)/,
+    );
   });
 
   it("shows setup required status for runtime session types that are not ready yet", () => {
@@ -857,7 +862,7 @@ describe("ChatSidebar session item interactions", () => {
     expect(screen.queryByLabelText("Session has unread updates")).toBeNull();
   });
 
-  it("opens the child-session browser from a parent session row", () => {
+  it("keeps child-session counts out of the parent session row", () => {
     mocks.sessionItems = [
       createSessionItem({
         key: "session:parent-1",
@@ -882,11 +887,6 @@ describe("ChatSidebar session item interactions", () => {
 
     renderSidebar();
 
-    fireEvent.click(screen.getByLabelText("View child sessions"));
-
-    expect(mocks.openChildSessionPanel).toHaveBeenCalledWith({
-      parentSessionKey: "session:parent-1",
-      activeChildSessionKey: "session:child-1",
-    });
+    expect(screen.queryByLabelText("View child sessions")).toBeNull();
   });
 });

package/src/features/chat/components/layout/chat-page-shell.tsx

@@ -8,6 +8,7 @@ import { useViewportLayout } from "@/app/hooks/use-viewport-layout";
 import { ChatMobileShell } from "@/platforms/mobile";
 import { InboxPage } from "@/features/inbox";
 import { PanelAppMainPage } from "@/features/panel-apps";
+import { useScrollRestoration } from "@/shared/hooks/use-scroll-restoration";
 export type MainPanelView = "chat" | "cron" | "skills" | "agents" | "inbox" | "panel-app";
 export type ChatPageProps = {
   view: MainPanelView;
@@ -36,6 +37,14 @@ type ChatPageLayoutProps = {
 };
 export function ChatPageLayout({ view, confirmDialog }: ChatPageLayoutProps) {
   const { isMobile } = useViewportLayout();
+  const cronScroll = useScrollRestoration<HTMLDivElement>({
+    restorationKey: "main-page:cron",
+  });
+  const agentsScroll = useScrollRestoration<HTMLDivElement>({
+    restorationKey: "main-page:agents",
+  });
+  const { onScroll: onCronScroll, scrollRef: cronScrollRef } = cronScroll;
+  const { onScroll: onAgentsScroll, scrollRef: agentsScrollRef } = agentsScroll;
 
   return (
     <div className="h-full flex">
@@ -52,13 +61,21 @@ export function ChatPageLayout({ view, confirmDialog }: ChatPageLayoutProps) {
           ) : view === "panel-app" ? (
             <PanelAppMainPage />
           ) : view === "cron" ? (
-            <div className="h-full overflow-auto custom-scrollbar">
+            <div
+              ref={cronScrollRef}
+              onScroll={onCronScroll}
+              className="h-full overflow-auto custom-scrollbar"
+            >
               <div className={`mx-auto w-full px-4 py-4 sm:px-6 sm:py-5 ${MANAGEMENT_PAGE_CANVAS_WIDTH_CLASS}`}>
                 <CronConfig />
               </div>
             </div>
           ) : view === "agents" ? (
-            <div className="h-full overflow-auto custom-scrollbar">
+            <div
+              ref={agentsScrollRef}
+              onScroll={onAgentsScroll}
+              className="h-full overflow-auto custom-scrollbar"
+            >
               <div className={`mx-auto w-full px-4 py-4 sm:px-6 sm:py-5 ${MANAGEMENT_PAGE_CANVAS_WIDTH_CLASS}`}>
                 <AgentsPage />
               </div>

package/src/features/chat/components/layout/chat-sidebar-desktop-layout.tsx

@@ -28,6 +28,7 @@ import { ChatSidebarUtilityMenu } from "@/features/chat/components/layout/chat-s
 import { PanelAppMainSidebarNav } from "@/features/panel-apps";
 import { isWindowsDesktopHost } from "@/platforms/desktop";
 import { viewportLayoutManager } from "@/app/managers/viewport-layout.manager";
+import { useScrollRestoration } from "@/shared/hooks/use-scroll-restoration";
 import {
   SIDEBAR_RAIL_CONTROL_CLASS,
   SIDEBAR_RAIL_ICON_CLASS,
@@ -63,7 +64,10 @@ function ChatSidebarCollapseButton({ isCollapsed }: { isCollapsed: boolean }) {
     <IconActionButton
       icon={<Icon className={SIDEBAR_RAIL_ICON_CLASS} />}
       label={label}
-      className={cn(SIDEBAR_RAIL_SURFACE_CLASS, isCollapsed && SIDEBAR_RAIL_CONTROL_CLASS)}
+      className={cn(
+        SIDEBAR_RAIL_SURFACE_CLASS,
+        isCollapsed && SIDEBAR_RAIL_CONTROL_CLASS,
+      )}
       onClick={viewportLayoutManager.toggleSidebarCollapsed}
     />
   );
@@ -77,7 +81,9 @@ export function ChatSidebarDesktopHeader({
   isCollapsed: boolean;
 }) {
   const isWindowsHost = isWindowsDesktopHost();
-  const shouldReserveMacWindowControls = typeof window !== "undefined" && window.nextclawDesktop?.platform === "darwin";
+  const shouldReserveMacWindowControls =
+    typeof window !== "undefined" &&
+    window.nextclawDesktop?.platform === "darwin";
 
   return (
     <div
@@ -124,9 +130,13 @@ export function ChatSidebarDesktopNav({
                 density="compact"
                 collapsed={isCollapsed}
                 indicator={item.target === "/inbox" && unreadCount > 0}
-                trailing={item.target === "/inbox" && unreadCount > 0
-                  ? unreadCount > 99 ? "99+" : unreadCount
-                  : undefined}
+                trailing={
+                  item.target === "/inbox" && unreadCount > 0
+                    ? unreadCount > 99
+                      ? "99+"
+                      : unreadCount
+                    : undefined
+                }
                 className={isCollapsed ? undefined : "rounded-lg px-2.5 py-1.5"}
               />
             </li>
@@ -145,8 +155,10 @@ export function ChatSidebarSessionArea({
   isLoading,
   isProjectFirstView,
   onAddProject,
+  onScrollNearEnd = () => undefined,
   onSelectMode,
   projectGroups,
+  projectCronJobCountByRoot,
   renderSessionItem,
   sessionTypeOptions,
 }: {
@@ -156,13 +168,20 @@ export function ChatSidebarSessionArea({
   isLoading: boolean;
   isProjectFirstView: boolean;
   onAddProject: () => void;
+  onScrollNearEnd?: () => void;
   onSelectMode: (mode: "time-first" | "project-first") => void;
   projectGroups: ReturnType<typeof groupSessionsByProject>;
+  projectCronJobCountByRoot: ReadonlyMap<string, number>;
   renderSessionItem: (item: NcpSessionListItemView) => JSX.Element;
   sessionTypeOptions: Parameters<
     typeof ChatSidebarSessionList
   >[0]["sessionTypeOptions"];
 }) {
+  const scrollRestoration = useScrollRestoration<HTMLDivElement>({
+    restorationKey: "chat-sidebar:sessions",
+    isEnabled: !isCollapsed,
+  });
+  const { onScroll: onScrollPositionSave, scrollRef } = scrollRestoration;
   if (isCollapsed) {
     return <div className="min-h-0 flex-1" aria-hidden="true" />;
   }
@@ -185,6 +204,14 @@ export function ChatSidebarSessionArea({
       </div>
 
       <div
+        ref={scrollRef}
+        onScroll={(event) => {
+          onScrollPositionSave(event);
+          const element = event.currentTarget;
+          if (element.scrollHeight - element.scrollTop - element.clientHeight < 600) {
+            onScrollNearEnd();
+          }
+        }}
         className={cn(
           "custom-scrollbar min-h-0 flex-1 overflow-y-auto px-3 pb-4 pt-1",
           SCROLL_BOTTOM_EDGE_FADE_CLASS,
@@ -195,6 +222,7 @@ export function ChatSidebarSessionArea({
           isProjectFirstView={isProjectFirstView}
           groups={groups}
           projectGroups={projectGroups}
+          projectCronJobCountByRoot={projectCronJobCountByRoot}
           defaultSessionType={defaultSessionType}
           sessionTypeOptions={sessionTypeOptions}
           renderSessionItem={renderSessionItem}

package/src/features/chat/components/layout/chat-sidebar.tsx

@@ -21,7 +21,10 @@ import {
   useCreateProject,
   useProjects,
 } from "@/shared/hooks/use-projects";
-import type { ProjectAddExistingRequest, ProjectCreateRequest } from "@/shared/lib/api";
+import type {
+  ProjectAddExistingRequest,
+  ProjectCreateRequest,
+} from "@/shared/lib/api";
 import { normalizeSessionProjectRootValue } from "@/shared/lib/session-project";
 import { cn } from "@/shared/lib/utils";
 import { LANGUAGE_OPTIONS, t, type I18nLanguage } from "@/shared/lib/i18n";
@@ -50,6 +53,7 @@ import { useChatNewSessionTypePreference } from "@/features/chat/features/sessio
 import { useViewportLayoutStore } from "@/app/stores/viewport-layout.store";
 import { SIDEBAR_RAIL_WIDTH_CLASS } from "@/app/components/layout/sidebar-rail.styles";
 import { ChatProjectAddDialog } from "@/features/chat/features/project/components/chat-project-add-dialog";
+import { useChatSidebarContextCounts } from "@/features/chat/features/session/hooks/use-chat-sidebar-context-counts";
 
 type ChatSidebarVariant = "desktop" | "mobile";
 
@@ -116,7 +120,9 @@ export function ChatSidebar({
   const projectsQuery = useProjects();
   const projectCreateMutation = useCreateProject();
   const projectAddExistingMutation = useAddExistingProject();
-  const { isLoading, items } = useNcpSessionListView();
+  const { allItems, hasMore, isLoading, isLoadingMore, items, loadMore } = useNcpSessionListView();
+  const { cronJobCountByProjectRoot, cronJobCountBySessionKey } =
+    useChatSidebarContextCounts(allItems);
   const { language, setLanguage } = useI18n();
   const { theme, setTheme } = useTheme();
   const currentThemeLabel = t(
@@ -160,21 +166,27 @@ export function ChatSidebar({
     [items],
   );
   const childSessionsByParentKey = useMemo(
-    () => groupChildSessionsByParentKey(items),
-    [items],
+    () => groupChildSessionsByParentKey(allItems),
+    [allItems],
   );
   const groups = useMemo(
     () => groupSessionsByDate(sortedItems, pinnedSessionKeys),
     [pinnedSessionKeys, sortedItems],
   );
   const projectGroups = useMemo(
-    () => groupSessionsByProject(
-      sortedItems,
-      pinnedSessionKeys,
+    () =>
+      groupSessionsByProject(
+        sortedItems,
+        pinnedSessionKeys,
+        pinnedProjectRoots,
+        projectsQuery.data?.projects ?? [],
+      ),
+    [
       pinnedProjectRoots,
-      projectsQuery.data?.projects ?? [],
-    ),
-    [pinnedProjectRoots, pinnedSessionKeys, projectsQuery.data?.projects, sortedItems],
+      pinnedSessionKeys,
+      projectsQuery.data?.projects,
+      sortedItems,
+    ],
   );
   const sessionTypeOptions = useMemo(
     () => buildSessionTypeOptions(sessionTypesData?.options ?? []),
@@ -220,6 +232,7 @@ export function ChatSidebar({
       optimisticReadAtBySessionKey={optimisticReadAtBySessionKey}
       agentsById={agentsById}
       childSessionsByParentKey={childSessionsByParentKey}
+      cronJobCount={cronJobCountBySessionKey.get(item.session.key) ?? 0}
       editingSessionKey={editingSessionKey}
       draftLabel={draftLabel}
       savingSessionKey={savingSessionKey}
@@ -227,12 +240,6 @@ export function ChatSidebar({
       isPinned={pinnedSessionKeys.has(item.session.key)}
       sessionTitle={getSessionTitle}
       onSelectSession={presenter.chatSessionListManager.selectSession}
-      onOpenChildSessions={(parentSessionKey, activeChildSessionKey) =>
-        presenter.chatThreadManager.openChildSessionPanel({
-          parentSessionKey,
-          activeChildSessionKey,
-        })
-      }
       onStartEditingSessionLabel={startEditingSessionLabel}
       onDraftLabelChange={setDraftLabel}
       onSaveSessionLabel={saveSessionLabel}
@@ -256,7 +263,9 @@ export function ChatSidebar({
     projectAddExistingMutation.reset();
     setIsProjectAddOpen(true);
   };
-  const createProjectFromSidebar = async (input: ProjectCreateRequest): Promise<void> => {
+  const createProjectFromSidebar = async (
+    input: ProjectCreateRequest,
+  ): Promise<void> => {
     await projectCreateMutation.mutateAsync(input);
     setIsProjectAddOpen(false);
   };
@@ -274,10 +283,7 @@ export function ChatSidebar({
         isMobileVariant
           ? "flex-1 overflow-hidden"
           : shouldCollapse
-            ? cn(
-                SIDEBAR_RAIL_WIDTH_CLASS,
-                "shrink-0",
-              )
+            ? cn(SIDEBAR_RAIL_WIDTH_CLASS, "shrink-0")
             : "w-[280px] shrink-0",
       )}
       data-sidebar-collapsed={shouldCollapse ? "true" : "false"}
@@ -337,8 +343,12 @@ export function ChatSidebar({
         isLoading={isLoading}
         isProjectFirstView={isProjectFirstView}
         onAddProject={openProjectAdd}
+        onScrollNearEnd={() => {
+          if (hasMore && !isLoadingMore) void loadMore();
+        }}
         onSelectMode={presenter.chatSessionListManager.setListMode}
         projectGroups={projectGroups}
+        projectCronJobCountByRoot={cronJobCountByProjectRoot}
         renderSessionItem={renderSessionItem}
         sessionTypeOptions={sessionTypeOptions}
       />

package/src/features/chat/features/conversation/hooks/__tests__/use-session-conversation-controller.test.tsx

@@ -1,6 +1,6 @@
 import { act, renderHook, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
-import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
+import { NextClawClientError, type UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpMessage, NcpRunHandle } from '@nextclaw/ncp';
 
 import { useSessionConversationController } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
@@ -448,3 +448,43 @@ describe('useSessionConversationController backend run queue', () => {
     expect(params.onSessionMaterialized).not.toHaveBeenCalled();
   });
 });
+
+describe('useSessionConversationController stale queue reconciliation', () => {
+  it('reconciles repeated stale queued actions without exposing their not-found errors', async () => {
+    const queuedInput = createQueuedInput();
+    const params = createControllerParams({ isRunning: true, queuedInputs: [queuedInput] });
+    params.runQueue.steerQueuedInput.mockRejectedValue(new NextClawClientError({
+      code: 'NOT_FOUND',
+      message: `queued input not found in session session-1: ${queuedInput.id}`,
+      status: 404,
+    }));
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    act(() => result.current.steerQueuedInput(queuedInput.id));
+    await waitFor(() => expect(params.runQueue.refreshPendingInputs).toHaveBeenCalledTimes(1));
+
+    act(() => result.current.steerQueuedInput(queuedInput.id));
+    await waitFor(() => expect(params.runQueue.refreshPendingInputs).toHaveBeenCalledTimes(2));
+
+    expect(params.setSendError).toHaveBeenLastCalledWith(null);
+    expect(params.setSendError).not.toHaveBeenCalledWith(expect.stringContaining('queued input not found'));
+  });
+
+  it('keeps a real steering failure visible', async () => {
+    const queuedInput = createQueuedInput();
+    const params = createControllerParams({ isRunning: true, queuedInputs: [queuedInput] });
+    params.runQueue.steerQueuedInput.mockRejectedValue(new NextClawClientError({
+      code: 'STEER_UNAVAILABLE',
+      message: 'The active runtime cannot accept this input at the next safe step.',
+      status: 409,
+    }));
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    act(() => result.current.steerQueuedInput(queuedInput.id));
+
+    await waitFor(() => expect(params.setSendError).toHaveBeenCalledWith(
+      'The active runtime cannot accept this input at the next safe step.',
+    ));
+    expect(params.runQueue.refreshPendingInputs).not.toHaveBeenCalled();
+  });
+});

package/src/features/chat/features/conversation/hooks/use-session-pending-input-actions.ts

@@ -1,7 +1,8 @@
 import { useCallback, useMemo, useState } from 'react';
-import type {
-  UiNcpSessionPendingInputView,
-  UiNcpSessionQueuedInputView,
+import {
+  NextClawClientError,
+  type UiNcpSessionPendingInputView,
+  type UiNcpSessionQueuedInputView,
 } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope } from '@nextclaw/ncp';
 
@@ -20,10 +21,17 @@ type ComposerDraftSnapshot = Pick<
 
 type SessionRunQueue = {
   readonly inputs: readonly UiNcpSessionQueuedInputView[];
+  readonly refreshPendingInputs: () => Promise<readonly UiNcpSessionPendingInputView[]>;
   readonly removeQueuedInput: (id: string) => Promise<UiNcpSessionQueuedInputView | null>;
   readonly steerQueuedInput: (id: string) => Promise<UiNcpSessionPendingInputView | null>;
 };
 
+function isStaleQueuedInputError(error: unknown): boolean {
+  return error instanceof NextClawClientError
+    && error.status === 404
+    && error.code === 'NOT_FOUND';
+}
+
 export type SubmittingQueuedInput = {
   readonly attachments: readonly SessionQueuedInputAttachmentPreview[];
   readonly id: string;
@@ -127,7 +135,17 @@ export function useQueuedInputActions(params: {
   const steerQueuedInput = useCallback((id: string) => {
     void runQueue.steerQueuedInput(id).then((steered) => {
       if (steered) setSendError(null);
-    }).catch((error) => {
+    }).catch(async (error) => {
+      if (isStaleQueuedInputError(error)) {
+        try {
+          await runQueue.refreshPendingInputs();
+          setSendError(null);
+          return;
+        } catch (refreshError) {
+          setSendError(refreshError instanceof Error ? refreshError.message : String(refreshError));
+          return;
+        }
+      }
       setSendError(error instanceof Error ? error.message : String(error));
     });
   }, [runQueue, setSendError]);

package/src/features/chat/features/message/utils/__tests__/chat-message-timeline-compaction.utils.test.ts

@@ -169,7 +169,7 @@ describe("mid-run compaction timeline projection", () => {
     ]);
   });
 
-  it("does not silently clamp an invalid canonical part boundary", () => {
+  it("does not render a temporarily unavailable canonical part boundary as a standalone marker", () => {
     const invalidCompaction = createCompactionMessage({
       assistantId: visibleMessage.id,
       coveredPartCount: 2,
@@ -183,7 +183,7 @@ describe("mid-run compaction timeline projection", () => {
     expect(buildChatMessageTimelineItems({
       rawMessages: [visibleMessage, invalidCompaction],
       messages: [{ id: visibleMessage.id } as never],
-    }).map((item) => item.kind)).toEqual(["message", "compaction"]);
+    }).map((item) => item.kind)).toEqual(["message"]);
   });
 
   it("offsets a continued assistant compaction within its canonical message", () => {

package/src/features/chat/features/message/utils/__tests__/chat-message-trigger-details.utils.test.ts

@@ -109,4 +109,39 @@ describe("buildChatMessageTriggerDetails", () => {
       "run-trigger-metadata",
     ]);
   });
+
+  it("keeps a completed steering user message actionable from persisted run metadata", () => {
+    const details = buildChatMessageTriggerDetails({
+      labels,
+      message: {
+        metadata: {
+          run_spec: {
+            runId: "run-1",
+            model: "openai/gpt-5.6",
+          },
+          run_trigger: {
+            version: 1,
+            actor: "human",
+            source: "internal",
+            sourceMessageId: "user-steering",
+            targetRunId: "run-1",
+            triggeredAt: "2026-08-25T13:39:04.000Z",
+          },
+        },
+      },
+    });
+
+    expect(details).toMatchObject({
+      triggerLabel: "More actions",
+      items: [{
+        key: "run-trigger-metadata",
+        dialog: {
+          rows: expect.arrayContaining([
+            { label: "Target run", value: "run-1" },
+            { label: "Run model", value: "openai/gpt-5.6" },
+          ]),
+        },
+      }],
+    });
+  });
 });

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

@@ -252,12 +252,12 @@ function projectVisibleChatMessageState(
       .forEach((placement) => {
         if (
           !Number.isSafeInteger(placement.boundaryIndex) ||
-          placement.boundaryIndex < 0 ||
-          placement.boundaryIndex > message.parts.length
+          placement.boundaryIndex < 0
         ) {
           inlineCompactionMessageIds.delete(placement.serviceMessageId);
           return;
         }
+        if (placement.boundaryIndex > message.parts.length) return;
         parts.splice(placement.boundaryIndex + insertedCount, 0, {
           type: "extension",
           extensionType: CONTEXT_COMPACTION_PART_EXTENSION_TYPE,

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

@@ -73,4 +73,54 @@ describe('useNcpAgentRuntime backend queue submission', () => {
       expect(result.current.visibleMessages).toEqual([queuedMessage]);
     });
   });
+
+  it('keeps a steered message in the pending projection instead of accepting it as a new run', async () => {
+    const manager = new DefaultNcpAgentConversationStateManager();
+    manager.hydrate({ sessionId: 'session-1', messages: [] });
+    await manager.dispatch({
+      type: NcpEventType.RunStarted,
+      payload: {
+        sessionId: 'session-1',
+        runId: 'run-1',
+        messageId: 'assistant-1',
+      },
+    });
+    const send = vi.fn(async (envelope: NcpAgentSendEnvelope) => ({
+      assistantMessageId: null,
+      delivery: 'steered' as const,
+      runId: 'run-1',
+      sessionId: 'session-1',
+      userMessageId: envelope.message.id,
+    }));
+    const client = {
+      abort: vi.fn(async () => undefined),
+      send,
+      stop: vi.fn(async () => undefined),
+      stream: vi.fn(async () => undefined),
+      subscribe: vi.fn(() => () => undefined),
+    } as unknown as NcpAgentClientEndpoint;
+    const { result } = renderHook(() => useNcpAgentRuntime({
+      client,
+      manager,
+      sessionId: 'session-1',
+    }));
+
+    await act(async () => {
+      await result.current.send({
+        delivery: 'prefer-steer',
+        message: {
+          id: 'user-steering',
+          sessionId: 'session-1',
+          role: 'user',
+          status: 'final',
+          parts: [{ type: 'text', text: 'change direction' }],
+          timestamp: '2026-08-25T00:00:00.000Z',
+        },
+        sessionId: 'session-1',
+      });
+    });
+
+    expect(result.current.visibleMessages).toEqual([]);
+    expect(result.current.snapshot.activeRun?.runId).toBe('run-1');
+  });
 });