@nextclaw/ui 0.20.0 → 0.20.2

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, isLoading, items } = 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"}
@@ -339,6 +345,7 @@ export function ChatSidebar({
         onAddProject={openProjectAdd}
         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/components/chat-message-list.container.tsx

@@ -20,9 +20,14 @@ import {
 } from "@/features/chat/features/message/utils/chat-message.utils";
 import { buildChatMessageProcessSummary } from "@/features/chat/features/message/utils/chat-message-process-summary.utils";
 import { buildChatMessageExecutionPresentation } from "@/features/chat/features/message/utils/chat-message-execution-summary.utils";
+import {
+  buildChatMessageTriggerDetails,
+  mergeChatMessageMoreActions,
+} from "@/features/chat/features/message/utils/chat-message-trigger-details.utils";
 import {
   buildChatMessageAdapterTexts,
   buildChatMessageExecutionLabels,
+  buildChatMessageTriggerLabels,
   buildChatMessageTexts,
 } from "@/features/chat/features/message/utils/chat-message-texts.utils";
 import {
@@ -94,6 +99,7 @@ class ChatMessageViewModelAdapter {
       language: Parameters<typeof formatDateTime>[1];
       processSummaryLabel: string | null;
       executionPresentationKey: string | null;
+      triggerDetailsKey: string | null;
       viewModel: ChatMessageViewModel;
     }
   >();
@@ -101,13 +107,14 @@ class ChatMessageViewModelAdapter {
   adapt = (params: {
     continuationRunning: boolean;
     executionLabels: ReturnType<typeof buildChatMessageExecutionLabels>;
+    triggerLabels: ReturnType<typeof buildChatMessageTriggerLabels>;
     language: Parameters<typeof formatDateTime>[1];
     processedLabel: string;
     rawMessages: readonly NcpMessage[];
     texts: ReturnType<typeof buildChatMessageAdapterTexts>;
   }): ChatMessageViewModel[] => {
     const {
-      continuationRunning, executionLabels, language, processedLabel, rawMessages, texts,
+      continuationRunning, executionLabels, triggerLabels, language, processedLabel, rawMessages, texts,
     } = params;
     return projectVisibleChatMessages(rawMessages, { continuationRunning }).map((message) => {
       const processSummary = buildChatMessageProcessSummary({
@@ -127,12 +134,28 @@ class ChatMessageViewModelAdapter {
         labels: executionLabels,
       });
       const executionPresentationKey = executionPresentation?.cacheKey ?? null;
+      const triggerDetails = buildChatMessageTriggerDetails({
+        message,
+        labels: triggerLabels,
+      });
+      const triggerDetailsKey = triggerDetails
+        ? JSON.stringify({
+          runTrigger: message.metadata?.run_trigger,
+          runSpec: message.metadata?.run_spec,
+          aiExecution: message.metadata?.ai_execution,
+        })
+        : null;
+      const moreActions = mergeChatMessageMoreActions(
+        executionPresentation?.moreActions,
+        triggerDetails,
+      );
       const cached = this.cache.get(message);
       if (
         cached &&
         cached.language === language &&
         cached.processSummaryLabel === processSummaryLabel &&
-        cached.executionPresentationKey === executionPresentationKey
+        cached.executionPresentationKey === executionPresentationKey &&
+        cached.triggerDetailsKey === triggerDetailsKey
       ) {
         return cached.viewModel;
       }
@@ -147,7 +170,7 @@ class ChatMessageViewModelAdapter {
           inlineTokens: readInlineTokensFromMetadata(message.metadata),
           processSummary,
           executionSummaryLabel: executionPresentation?.summaryLabel,
-          moreActions: executionPresentation?.moreActions,
+          moreActions,
         },
         parts: adaptNcpMessagePartsForChat(message.parts) as ChatMessageSource["parts"],
       };
@@ -160,6 +183,7 @@ class ChatMessageViewModelAdapter {
         language,
         processSummaryLabel,
         executionPresentationKey,
+        triggerDetailsKey,
         viewModel,
       });
       return viewModel;
@@ -295,17 +319,22 @@ export function ChatMessageListContainer({
     () => buildChatMessageExecutionLabels(language),
     [language],
   );
+  const triggerLabels = useMemo(
+    () => buildChatMessageTriggerLabels(language),
+    [language],
+  );
   const adaptedMessages = useMemo(
     () =>
       chatMessageViewModelAdapter.adapt({
         continuationRunning: isSending,
         executionLabels,
+        triggerLabels,
         language,
         processedLabel: t("chatProcessSummaryProcessed"),
         rawMessages,
         texts,
       }),
-    [executionLabels, isSending, language, rawMessages, texts],
+    [executionLabels, isSending, language, rawMessages, texts, triggerLabels],
   );
   const { handleMessageAction, messages, renderMessageContent } =
     useChatMessageActions({

package/src/features/chat/features/message/utils/__tests__/chat-message-file-operation.utils.test.ts

@@ -154,6 +154,12 @@ it("uses structured edit-file result line numbers after the tool finishes", () =
       },
     },
   });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
 });
 
 it("builds write-file previews from partial native args before the JSON is complete", () => {
@@ -261,6 +267,12 @@ it("keeps completed write-file cards in preview mode instead of falling back to
       output: "Wrote 3906 bytes to games/snake.html",
     },
   });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
 });
 
 it("renders codex file_change results as structured diff previews", () => {
@@ -337,4 +349,178 @@ it("renders codex file_change results as structured diff previews", () => {
       },
     },
   });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
+});
+
+it("uses a read-file preview as the single visible representation of file content", () => {
+  const adapted = adapt([
+    {
+      id: "assistant-read-result",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "read-result-1",
+            toolName: "read_file",
+            args: JSON.stringify({ path: "docs/readme.md" }),
+            parsedArgs: { path: "docs/readme.md" },
+            result: "1: first line\n2: second line\n</content>",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "read_file",
+      summary: "docs/readme.md",
+      fileOperation: {
+        blocks: [
+          {
+            display: "preview",
+            path: "docs/readme.md",
+            lines: expect.arrayContaining([
+              expect.objectContaining({ text: "1: first line" }),
+              expect.objectContaining({ text: "2: second line" }),
+            ]),
+          },
+        ],
+      },
+    },
+  });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
+});
+
+it("uses an apply-patch preview as the single visible representation of the patch", () => {
+  const patch = [
+    "*** Begin Patch",
+    "*** Update File: src/app.ts",
+    "@@",
+    "-const color = 'red';",
+    "+const color = 'blue';",
+    "*** End Patch",
+  ].join("\n");
+  const adapted = adapt([
+    {
+      id: "assistant-apply-patch-result",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "apply-patch-result-1",
+            toolName: "apply_patch",
+            args: patch,
+            result: "Done!",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "apply_patch",
+      summary: "src/app.ts",
+      fileOperation: {
+        blocks: [
+          {
+            path: "src/app.ts",
+            lines: [
+              expect.objectContaining({ kind: "remove", text: "const color = 'red';" }),
+              expect.objectContaining({ kind: "add", text: "const color = 'blue';" }),
+            ],
+          },
+        ],
+      },
+    },
+  });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
+});
+
+it("keeps raw file-tool results when no structured preview can be built", () => {
+  const adapted = adapt([
+    {
+      id: "assistant-read-result-without-path",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "read-result-without-path-1",
+            toolName: "read_file",
+            result: "raw file content",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "read_file",
+      outputData: "raw file content",
+    },
+  });
+});
+
+it("keeps file-tool errors visible even when input can build a preview", () => {
+  const adapted = adapt([
+    {
+      id: "assistant-write-error",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "write-error-1",
+            toolName: "write_file",
+            parsedArgs: {
+              path: "src/app.ts",
+              content: "const color = 'blue';",
+            },
+            error: "Permission denied",
+            result: "write failed",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "write_file",
+      statusTone: "error",
+      output: "Permission denied",
+      outputData: "write failed",
+      fileOperation: {
+        blocks: [expect.objectContaining({ path: "src/app.ts" })],
+      },
+    },
+  });
 });

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

@@ -1,6 +1,7 @@
 import { expect, it, vi } from "vitest";
 import {
   buildChatMessageExecutionLabels,
+  buildChatMessageTriggerLabels,
   buildChatMessageTexts,
 } from "@/features/chat/features/message/utils/chat-message-texts.utils";
 
@@ -25,6 +26,14 @@ it("provides localized status keys for built-in tool categories", () => {
   });
 });
 
+it("provides localized labels for run trigger details", () => {
+  expect(buildChatMessageTriggerLabels("zh")).toMatchObject({
+    viewTrigger: "chatRunTriggerView",
+    fields: { sourceModel: "chatRunTriggerSourceModel" },
+    actors: { agent: "chatRunTriggerActorAgent" },
+  });
+});
+
 it("provides localized labels for the AI execution metadata action", () => {
   expect(buildChatMessageExecutionLabels("zh")).toMatchObject({
     moreActions: "chatMessageMoreActions",

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

@@ -125,7 +125,9 @@ describe("chat message timeline visibility", () => {
     })).toBe(false);
     expect(isVisibleChatMessage(visibleMessage)).toBe(true);
   });
+});
 
+describe("chat message continuation projection", () => {
   it("projects continued assistant output into the interrupted message", () => {
     const messages = projectVisibleChatMessages([
       {
@@ -253,3 +255,72 @@ describe("chat message timeline visibility", () => {
     ]).map((message) => message.id)).toEqual(["user-1", "assistant-1"]);
   });
 });
+
+describe("child session timeline visibility", () => {
+  it("does not repeat inherited compaction markers", () => {
+    const childMessage = {
+      ...visibleMessage,
+      id: "child-user",
+      role: "user" as const,
+      timestamp: "2026-08-24T15:50:23.415Z",
+      parts: [{ type: "text" as const, text: "child request" }],
+    };
+    const inheritedCompactions = Array.from({ length: 5 }, (_, index) => ({
+      ...visibleMessage,
+      id: `child-session:inherited:${index + 1}`,
+      role: "service" as const,
+      timestamp: `2026-08-24T15:0${index}:00.000Z`,
+      parts: [{ type: "text" as const, text: "Earlier context was auto-compacted" }],
+      metadata: {
+        inherited_from_session_id: "parent-session",
+        inherited_from_message_id: `parent-compaction-${index + 1}`,
+        nextclaw_timeline_kind: "context_compaction",
+        checkpoint: {
+          id: "parent-checkpoint",
+          status: "compressed",
+          summary: "Compressed parent context",
+          coveredMessageCount: (index + 1) * 100,
+          coveredSessionMessageCount: (index + 1) * 100,
+          originalEstimatedTokens: 76_000,
+          projectedEstimatedTokens: 51_000,
+          createdAt: "2026-08-24T15:00:00.000Z",
+          updatedAt: `2026-08-24T15:0${index}:00.000Z`,
+        },
+      },
+    } satisfies NcpMessage));
+    const items = buildChatMessageTimelineItems({
+      rawMessages: [...inheritedCompactions, childMessage],
+      messages: [{ id: childMessage.id } as never],
+    });
+
+    expect(items.map((item) => item.kind)).toEqual([
+      "context-inheritance",
+      "message",
+    ]);
+
+    const childCompaction = {
+      ...inheritedCompactions[0]!,
+      id: "child-compaction",
+      metadata: {
+        ...inheritedCompactions[0]!.metadata,
+        inherited_from_session_id: undefined,
+        inherited_from_message_id: undefined,
+      },
+    } satisfies NcpMessage;
+    const childAssistant = {
+      ...visibleMessage,
+      id: "child-assistant",
+      timestamp: "2026-08-24T15:51:00.000Z",
+    };
+
+    expect(buildChatMessageTimelineItems({
+      rawMessages: [...inheritedCompactions, childMessage, childCompaction, childAssistant],
+      messages: [{ id: childMessage.id } as never, { id: childAssistant.id } as never],
+    }).map((item) => item.kind)).toEqual([
+      "context-inheritance",
+      "message",
+      "compaction",
+      "message",
+    ]);
+  });
+});