@nextclaw/ui 0.20.0 → 0.20.2

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

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildChatMessageTriggerDetails,
+  mergeChatMessageMoreActions,
+} from "@/features/chat/features/message/utils/chat-message-trigger-details.utils";
+
+const labels = {
+  moreActions: "More actions",
+  viewTrigger: "View trigger details",
+  title: "Run trigger",
+  description: "Why this run started.",
+  close: "Close",
+  notAvailable: "Not available",
+  fields: {
+    actor: "Actor",
+    source: "Source",
+    triggeredAt: "Triggered at",
+    targetRunId: "Target run",
+    sourceSessionId: "Source session",
+    sourceMessageId: "Source message",
+    sourceRunId: "Source run",
+    sourceToolCallId: "Source tool call",
+    sourceRequestId: "Source request",
+    sourceModel: "Source model",
+    targetModel: "Run model",
+    sourceContext: "Source context",
+    raw: "Raw metadata",
+  },
+  actors: {
+    human: "Human",
+    agent: "Agent",
+    automation: "Automation",
+    system: "System",
+  },
+};
+
+describe("buildChatMessageTriggerDetails", () => {
+  it("projects structured and raw provenance rows", () => {
+    const details = buildChatMessageTriggerDetails({
+      labels,
+      message: {
+        metadata: {
+          run_trigger: {
+            version: 1,
+            actor: "agent",
+            source: "sessions_spawn",
+            triggeredAt: "2026-08-25T00:00:00.000Z",
+            targetRunId: "target-run",
+            sourceSessionId: "source-session",
+            sourceMessageId: "source-message",
+            sourceRunId: "source-run",
+            sourceToolCallId: "source-tool-call",
+            sourceRequestId: "source-request",
+            sourceModel: "openai/gpt-5.6",
+            sourceContext: { channel: "telegram", chatId: "chat-1" },
+          },
+          run_spec: {
+            runId: "target-run",
+            model: "minimax/MiniMax-M3",
+          },
+        },
+      },
+    });
+
+    expect(details?.triggerLabel).toBe("More actions");
+    expect(details?.items[0]?.dialog.rows).toEqual(expect.arrayContaining([
+      { label: "Actor", value: "Agent" },
+      { label: "Source model", value: "openai/gpt-5.6" },
+      { label: "Run model", value: "minimax/MiniMax-M3" },
+      { label: "Source context", value: expect.stringContaining("telegram") },
+      expect.objectContaining({ label: "Raw metadata" }),
+    ]));
+    expect(details?.items[0]?.dialog.rows.find(
+      (row) => row.label === "Raw metadata",
+    )?.value).toContain("run_spec");
+  });
+
+  it("does not create an empty action for legacy messages", () => {
+    expect(buildChatMessageTriggerDetails({ labels, message: {} })).toBeNull();
+  });
+
+  it("keeps trigger-only messages actionable and merges assistant details in order", () => {
+    const triggerDetails = buildChatMessageTriggerDetails({
+      labels,
+      message: {
+        metadata: {
+          run_trigger: {
+            version: 1,
+            actor: "human",
+            source: "ui-http",
+            triggeredAt: "2026-08-25T00:00:00.000Z",
+            targetRunId: "run-1",
+          },
+        },
+      },
+    });
+    expect(mergeChatMessageMoreActions(null, triggerDetails)?.items.map(
+      (item) => item.key,
+    )).toEqual(["run-trigger-metadata"]);
+    expect(mergeChatMessageMoreActions({
+      triggerLabel: "More actions",
+      items: [{
+        key: "ai-execution-metadata",
+        label: "View run metadata",
+        dialog: { title: "Run", closeLabel: "Close", rows: [] },
+      }],
+    }, triggerDetails)?.items.map((item) => item.key)).toEqual([
+      "ai-execution-metadata",
+      "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-part.utils.ts

@@ -174,7 +174,7 @@ function buildToolInvocationPart(
     detail,
     inputData: fileOperationCardData ? undefined : invocation.parsedArgs ?? invocation.args,
     text: shouldShowRawResult && rawResult ? rawResult : undefined,
-    outputData: invocation.result,
+    outputData: shouldShowRawResult ? invocation.result : undefined,
     callId: invocation.toolCallId || undefined,
     toolCallId: invocation.toolCallId || undefined,
     ...(invocation.execution ? { execution: invocation.execution } : {}),

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

@@ -1,5 +1,6 @@
 import type { ChatMessageTexts } from "@nextclaw/agent-chat-ui";
 import type { ChatMessageExecutionPresentationLabels } from "./chat-message-execution-summary.utils";
+import type { ChatMessageTriggerDetailsLabels } from "./chat-message-trigger-details.utils";
 import type { ChatMessageAdapterTexts } from "@/features/chat/features/message/utils/chat-message.utils";
 import { t } from "@/shared/lib/i18n";
 
@@ -140,6 +141,41 @@ export function buildChatMessageExecutionLabels(
   };
 }
 
+export function buildChatMessageTriggerLabels(
+  language: string,
+): ChatMessageTriggerDetailsLabels {
+  void language;
+  return {
+    moreActions: t("chatMessageMoreActions"),
+    viewTrigger: t("chatRunTriggerView"),
+    title: t("chatRunTriggerTitle"),
+    description: t("chatRunTriggerDescription"),
+    close: t("chatRunTriggerClose"),
+    notAvailable: t("chatAiExecutionNotAvailable"),
+    fields: {
+      actor: t("chatRunTriggerActor"),
+      source: t("chatRunTriggerSource"),
+      triggeredAt: t("chatRunTriggerTime"),
+      targetRunId: t("chatRunTriggerTargetRun"),
+      sourceSessionId: t("chatRunTriggerSourceSession"),
+      sourceMessageId: t("chatRunTriggerSourceMessage"),
+      sourceRunId: t("chatRunTriggerSourceRun"),
+      sourceToolCallId: t("chatRunTriggerSourceToolCall"),
+      sourceRequestId: t("chatRunTriggerSourceRequest"),
+      sourceModel: t("chatRunTriggerSourceModel"),
+      targetModel: t("chatRunTriggerTargetModel"),
+      sourceContext: t("chatRunTriggerSourceContext"),
+      raw: t("chatRunTriggerRaw"),
+    },
+    actors: {
+      human: t("chatRunTriggerActorHuman"),
+      agent: t("chatRunTriggerActorAgent"),
+      automation: t("chatRunTriggerActorAutomation"),
+      system: t("chatRunTriggerActorSystem"),
+    },
+  };
+}
+
 export function buildChatMessageTexts(
   language: string,
 ): ChatMessageTexts {

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

@@ -0,0 +1,118 @@
+import type { ChatMessageMoreActionsViewModel } from "@nextclaw/agent-chat-ui";
+import {
+  readNcpAiExecutionMetadata,
+  readNcpRunTriggerMetadata,
+  type NcpMessage,
+  type NcpRunTriggerActor,
+} from "@nextclaw/ncp";
+
+export type ChatMessageTriggerDetailsLabels = {
+  moreActions: string;
+  viewTrigger: string;
+  title: string;
+  description: string;
+  close: string;
+  notAvailable: string;
+  fields: {
+    actor: string;
+    source: string;
+    triggeredAt: string;
+    targetRunId: string;
+    sourceSessionId: string;
+    sourceMessageId: string;
+    sourceRunId: string;
+    sourceToolCallId: string;
+    sourceRequestId: string;
+    sourceModel: string;
+    targetModel: string;
+    sourceContext: string;
+    raw: string;
+  };
+  actors: Record<NcpRunTriggerActor, string>;
+};
+
+export function mergeChatMessageMoreActions(
+  ...candidates: Array<ChatMessageMoreActionsViewModel | null | undefined>
+): ChatMessageMoreActionsViewModel | undefined {
+  const available = candidates.filter(
+    (candidate): candidate is ChatMessageMoreActionsViewModel =>
+      Boolean(candidate?.items.length),
+  );
+  if (available.length === 0) return undefined;
+  return {
+    triggerLabel: available[0]!.triggerLabel,
+    items: available.flatMap((candidate) => candidate.items),
+  };
+}
+
+function readRunSpec(
+  metadata: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | null {
+  const value = metadata?.run_spec;
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function readTargetModel(
+  metadata: Record<string, unknown> | null | undefined,
+): string | undefined {
+  const runSpecModel = readRunSpec(metadata)?.model;
+  if (typeof runSpecModel === "string" && runSpecModel.trim()) {
+    return runSpecModel.trim();
+  }
+  return readNcpAiExecutionMetadata(metadata)?.model;
+}
+
+export function buildChatMessageTriggerDetails(params: {
+  labels: ChatMessageTriggerDetailsLabels;
+  message: Pick<NcpMessage, "metadata">;
+}): ChatMessageMoreActionsViewModel | null {
+  const { labels, message } = params;
+  const trigger = readNcpRunTriggerMetadata(message.metadata);
+  if (!trigger) return null;
+  const { fields } = labels;
+  const runSpec = readRunSpec(message.metadata);
+  const rows = [
+    { label: fields.actor, value: labels.actors[trigger.actor] },
+    { label: fields.source, value: trigger.source },
+    { label: fields.triggeredAt, value: trigger.triggeredAt },
+    { label: fields.targetRunId, value: trigger.targetRunId },
+    { label: fields.sourceSessionId, value: trigger.sourceSessionId },
+    { label: fields.sourceMessageId, value: trigger.sourceMessageId },
+    { label: fields.sourceRunId, value: trigger.sourceRunId },
+    { label: fields.sourceToolCallId, value: trigger.sourceToolCallId },
+    { label: fields.sourceRequestId, value: trigger.sourceRequestId },
+    { label: fields.sourceModel, value: trigger.sourceModel },
+    { label: fields.targetModel, value: readTargetModel(message.metadata) },
+    {
+      label: fields.sourceContext,
+      value: trigger.sourceContext
+        ? JSON.stringify(trigger.sourceContext, null, 2)
+        : undefined,
+    },
+  ].map((row) => ({
+    label: row.label,
+    value: row.value ?? labels.notAvailable,
+  }));
+  rows.push({
+    label: fields.raw,
+    value: JSON.stringify({
+      run_trigger: trigger,
+      ...(runSpec ? { run_spec: runSpec } : {}),
+    }, null, 2),
+  });
+  return {
+    triggerLabel: labels.moreActions,
+    items: [{
+      key: "run-trigger-metadata",
+      label: labels.viewTrigger,
+      dialog: {
+        title: labels.title,
+        description: labels.description,
+        closeLabel: labels.close,
+        rows,
+      },
+    }],
+  };
+}

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');
+  });
 });

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

@@ -1,4 +1,4 @@
-import { act, renderHook, waitFor } from "@testing-library/react";
+import { act, render, renderHook, waitFor } from "@testing-library/react";
 import {
   type NcpAgentClientEndpoint,
   type NcpAgentSendEnvelope,
@@ -158,6 +158,29 @@ class ExistingSessionLiveClient implements NcpAgentClientEndpoint {
   };
 }
 
+function RuntimeMessagesProbe({
+  client,
+  manager,
+}: {
+  client: NcpAgentClientEndpoint;
+  manager: DefaultNcpAgentConversationStateManager;
+}) {
+  const { visibleMessages } = useNcpAgentRuntime({
+    sessionId: "ncp-mt7hs0u9-15yce6jv",
+    client,
+    manager,
+  });
+  return (
+    <div data-testid="runtime-messages">
+      {visibleMessages.map((message) => (
+        <div key={message.id} data-message-id={message.id}>
+          {message.id}
+        </div>
+      ))}
+    </div>
+  );
+}
+
 function readAssistantText(messages: readonly NcpMessage[]): string {
   const assistant = messages.find((message) => message.role === "assistant");
   return assistant?.parts
@@ -421,6 +444,72 @@ describe("useNcpAgentRuntime", () => {
     ]);
   });
 
+  it("keeps the live assistant boundary and DOM identity when a steered user has an earlier timestamp", async () => {
+    const client = new DeferredSendClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    manager.hydrate({
+      sessionId: "ncp-mt7hs0u9-15yce6jv",
+      messages: [{
+        id: "user-mt7jp7vd",
+        sessionId: "ncp-mt7hs0u9-15yce6jv",
+        role: "user",
+        status: "final",
+        parts: [{ type: "text", text: "first" }],
+        timestamp: "2026-08-24T18:04:10.460Z",
+      }],
+    });
+    await manager.dispatchBatch([
+      {
+        type: NcpEventType.RunStarted,
+        payload: {
+          sessionId: "ncp-mt7hs0u9-15yce6jv",
+          runId: "agent-run-7c65d8b1-6bda-4f08-a2ad-d5f5318366fb",
+        },
+      },
+      {
+        type: NcpEventType.MessageReasoningDelta,
+        payload: {
+          sessionId: "ncp-mt7hs0u9-15yce6jv",
+          messageId: "assistant-message-2629eaf9-c4ce-4562-b22d-c70f1e8c85e2",
+          delta: "Planning",
+        },
+      },
+    ]);
+
+    const view = render(<RuntimeMessagesProbe client={client} manager={manager} />);
+    const assistantSelector = '[data-message-id="assistant-message-2629eaf9-c4ce-4562-b22d-c70f1e8c85e2"]';
+    const assistantNode = view.container.querySelector(assistantSelector);
+    expect(assistantNode).not.toBeNull();
+
+    await act(async () => {
+      await manager.dispatch({
+        type: NcpEventType.MessageSent,
+        payload: {
+          sessionId: "ncp-mt7hs0u9-15yce6jv",
+          message: {
+            id: "user-mt7jpad5",
+            sessionId: "ncp-mt7hs0u9-15yce6jv",
+            role: "user",
+            status: "final",
+            parts: [{ type: "text", text: "steer" }],
+            timestamp: "2026-08-24T18:04:13.625Z",
+          },
+        },
+      });
+    });
+
+    await waitFor(() => {
+      const ids = [...view.container.querySelectorAll("[data-message-id]")]
+        .map((node) => node.getAttribute("data-message-id"));
+      expect(ids).toEqual([
+        "user-mt7jp7vd",
+        "assistant-message-2629eaf9-c4ce-4562-b22d-c70f1e8c85e2",
+        "user-mt7jpad5",
+      ]);
+    });
+    expect(view.container.querySelector(assistantSelector)).toBe(assistantNode);
+  });
+
 });
 
 describe("useNcpAgentRuntime commands and live stream", () => {

package/src/features/chat/features/ncp/hooks/__tests__/use-ncp-session-list-view.test.tsx

@@ -62,13 +62,34 @@ describe("useNcpSessionListView", () => {
   it("can override the hidden sidebar query for header switching", () => {
     useChatSessionListStore.getState().setSnapshot({ query: "Alpha" });
 
-    const { result } = renderHook(() =>
-      useNcpSessionListView({ query: "" }),
-    );
+    const { result } = renderHook(() => useNcpSessionListView({ query: "" }));
 
     expect(result.current.items.map((item) => item.session.key)).toEqual([
       "session:alpha",
       "session:beta",
     ]);
   });
+
+  it("keeps hidden child sessions available for sidebar context counts", () => {
+    mocks.sessions.push({
+      ...createSummary("session:alpha:child", "Child Task"),
+      metadata: {
+        label: "Child Task",
+        session_type: "native",
+        parent_session_id: "session:alpha",
+      },
+    });
+
+    const { result } = renderHook(() => useNcpSessionListView());
+
+    expect(result.current.items.map((item) => item.session.key)).toEqual([
+      "session:alpha",
+      "session:beta",
+    ]);
+    expect(result.current.allItems.map((item) => item.session.key)).toEqual([
+      "session:alpha",
+      "session:beta",
+      "session:alpha:child",
+    ]);
+  });
 });

package/src/features/chat/features/ncp/hooks/use-ncp-session-list-view.ts

@@ -1,17 +1,20 @@
-import { useMemo } from 'react';
-import type { SessionEntryView } from '@/shared/lib/api';
-import { sessionMatchesQuery } from '@/features/chat/features/session/utils/chat-session-display.utils';
-import { adaptNcpSessionSummaries } from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
-import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
-import { useNcpSessions } from '@/features/chat/features/ncp/hooks/use-ncp-session-queries';
-import type { SessionRunStatus } from '@/features/chat/types/session-run-status.types';
+import { useMemo } from "react";
+import type { SessionEntryView } from "@/shared/lib/api";
+import { sessionMatchesQuery } from "@/features/chat/features/session/utils/chat-session-display.utils";
+import { adaptNcpSessionSummaries } from "@/features/chat/features/session/utils/ncp-session-adapter.utils";
+import { useChatSessionListStore } from "@/features/chat/stores/chat-session-list.store";
+import { useNcpSessions } from "@/features/chat/features/ncp/hooks/use-ncp-session-queries";
+import type { SessionRunStatus } from "@/features/chat/types/session-run-status.types";
 
 export type NcpSessionListItemView = {
   session: SessionEntryView;
   runStatus?: SessionRunStatus;
 };
 
-function filterSessionsByQuery(sessions: readonly SessionEntryView[], query: string): SessionEntryView[] {
+function filterSessionsByQuery(
+  sessions: readonly SessionEntryView[],
+  query: string,
+): SessionEntryView[] {
   return sessions.filter((session) => sessionMatchesQuery(session, query));
 }
 
@@ -22,26 +25,39 @@ function shouldShowSessionInSidebar(session: SessionEntryView): boolean {
   return session.isPromotedChildSession === true;
 }
 
-export function useNcpSessionListView(params: { limit?: number; query?: string | null } = {}) {
+export function useNcpSessionListView(
+  params: { limit?: number; query?: string | null } = {},
+) {
   const storedQuery = useChatSessionListStore((state) => state.snapshot.query);
   const query = params.query ?? storedQuery;
   const sessionsQuery = useNcpSessions({ limit: params.limit ?? 200 });
 
-  const items = useMemo<NcpSessionListItemView[]>(() => {
+  const allItems = useMemo<NcpSessionListItemView[]>(() => {
     const summaries = sessionsQuery.data?.sessions ?? [];
-    const sessions = adaptNcpSessionSummaries(summaries).filter(
-      shouldShowSessionInSidebar,
-    );
-    const filteredSessions = filterSessionsByQuery(sessions, query);
-
-    return filteredSessions.map((session) => ({
+    return adaptNcpSessionSummaries(summaries).map((session) => ({
       session,
-      runStatus: session.status === 'running' ? 'running' : undefined
+      runStatus: session.status === "running" ? "running" : undefined,
     }));
-  }, [query, sessionsQuery.data?.sessions]);
+  }, [sessionsQuery.data?.sessions]);
+  const items = useMemo<NcpSessionListItemView[]>(() => {
+    const visibleItems = allItems.filter(({ session }) =>
+      shouldShowSessionInSidebar(session),
+    );
+    const matchingSessionKeys = new Set(
+      filterSessionsByQuery(
+        visibleItems.map(({ session }) => session),
+        query,
+      ).map((session) => session.key),
+    );
+
+    return visibleItems.filter(({ session }) =>
+      matchingSessionKeys.has(session.key),
+    );
+  }, [allItems, query]);
 
   return {
+    allItems,
     isLoading: sessionsQuery.isLoading,
-    items
+    items,
   };
 }

package/src/features/chat/features/session/components/__tests__/chat-sidebar-project-groups.test.tsx

@@ -1,4 +1,5 @@
-import { fireEvent, render, screen } from "@testing-library/react";
+import { fireEvent, render, screen, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { ChatSidebarProjectGroups } from "@/features/chat/features/session/components/chat-sidebar-project-groups";
 import { useChatSessionListStore } from "@/features/chat/stores/chat-session-list.store";
@@ -38,6 +39,7 @@ function renderProjectGroups(isPinned = false) {
   return render(
     <ChatSidebarProjectGroups
       groups={[{ ...projectGroup, isPinned }]}
+      projectCronJobCountByRoot={new Map([[projectGroup.projectRoot, 2]])}
       defaultSessionType="native"
       sessionTypeOptions={[
         { value: "native", label: "Native", icon: null, ready: true },
@@ -74,7 +76,15 @@ describe("ChatSidebarProjectGroups", () => {
     expect(header.parentElement?.className).toContain("h-8");
     expect(header.parentElement?.className).toContain("hover:bg-gray-200/60");
     expect(header.parentElement?.className).not.toContain("focus-within:bg");
-    expect(screen.getByText("analysis-project").nextElementSibling?.tagName).toBe("svg");
+    expect(
+      screen.getByText("analysis-project").nextElementSibling?.tagName,
+    ).toBe("svg");
+    expect(
+      screen
+        .getByText("analysis-project")
+        .nextElementSibling?.getAttribute("class"),
+    ).toContain("opacity-0");
+    expect(screen.queryByText("Sessions")).toBeNull();
 
     fireEvent.click(header);
 
@@ -87,6 +97,20 @@ describe("ChatSidebarProjectGroups", () => {
     expect(screen.queryByText("Project session")).toBeNull();
   });
 
+  it("shows project context from the row on hover", async () => {
+    const user = userEvent.setup();
+    renderProjectGroups();
+
+    await user.hover(screen.getByLabelText("Collapse project"));
+
+    const tooltip = await screen.findByRole("tooltip");
+    expect(within(tooltip).getByText("Path")).toBeTruthy();
+    expect(within(tooltip).getByText("Sessions")).toBeTruthy();
+    expect(within(tooltip).getByText("Scheduled tasks")).toBeTruthy();
+    expect(within(tooltip).getByText("/tmp/analysis-project")).toBeTruthy();
+    expect(within(tooltip).getByText("2")).toBeTruthy();
+  });
+
   it("keeps project creation and pinning in one trailing action cluster", () => {
     renderProjectGroups();