@nextclaw/ui 0.24.2 → 0.25.0

package/src/features/chat/features/conversation/hooks/__tests__/use-chat-voice-input.test.tsx

@@ -0,0 +1,185 @@
+import { act, renderHook } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatVoiceInputManager, type SpeechRecognitionLike } from '@/features/chat/managers/chat-voice-input.manager';
+import { useChatVoiceInput } from '@/features/chat/features/conversation/hooks/use-chat-voice-input';
+import { isVoiceShortcut, useChatVoiceShortcutStore } from '@/features/chat/stores/chat-voice-shortcut.store';
+import type { ChatComposerDictationSession } from '@nextclaw/agent-chat-ui';
+
+class Recognition implements SpeechRecognitionLike {
+  lang = '';
+  continuous = false;
+  interimResults = false;
+  start = vi.fn();
+  stop = vi.fn();
+  abort = vi.fn();
+  onstart: SpeechRecognitionLike['onstart'] = null;
+  onend: SpeechRecognitionLike['onend'] = null;
+  onerror: SpeechRecognitionLike['onerror'] = null;
+  onresult: SpeechRecognitionLike['onresult'] = null;
+  result = (...texts: string[]) => this.onresult?.({ results: texts.map((transcript) => ({ isFinal: true, 0: { transcript } })) });
+}
+let recognition: Recognition;
+let manager: ChatVoiceInputManager;
+let commit = vi.fn<(text?: string) => void>();
+let draft: ChatComposerDictationSession;
+const beginDraft = () => draft;
+beforeEach(() => {
+  vi.useFakeTimers();
+  recognition = new Recognition();
+  manager = new ChatVoiceInputManager(() => recognition);
+  commit = vi.fn<(text?: string) => void>();
+  draft = { commit, update: vi.fn(), cancel: vi.fn() };
+  useChatVoiceShortcutStore.getState().setShortcut(null);
+  vi.spyOn(document, 'hasFocus').mockReturnValue(true);
+});
+afterEach(() => {
+  manager.cancel();
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+
+describe('dictation lifecycle', () => {
+  it('waits for the final transcript before opening settings without restarting recording', () => {
+    manager.start('zh', 'one', draft);
+    recognition.onstart?.();
+    recognition.result('first');
+    manager.openSettings();
+    expect(manager.getSnapshot().phase).toBe('stopping');
+    expect(commit).not.toHaveBeenCalled();
+    recognition.result('first', 'tail');
+    recognition.onend?.();
+    expect(commit).toHaveBeenCalledExactlyOnceWith('first tail');
+    expect(manager.getSnapshot().phase).toBe('ready');
+    manager.cancel();
+    expect(recognition.start).toHaveBeenCalledOnce();
+  });
+  it('still opens settings when finishing recognition fails', () => {
+    manager.start('en', 'one', draft);
+    recognition.onstart?.();
+    manager.openSettings();
+    recognition.onerror?.({ error: 'no-speech' });
+    expect(manager.getSnapshot()).toMatchObject({ phase: 'ready', error: null, text: '', interim: '' });
+  });
+  it('replaces cumulative results, waits for the final tail, and inserts once', () => {
+    manager.start('zh', 'one', draft);
+    expect(manager.getSnapshot().phase).toBe('starting');
+    recognition.onstart?.();
+    recognition.result('hello');
+    recognition.result('hello', 'world');
+    expect(commit).not.toHaveBeenCalled();
+    manager.finish();
+    expect(recognition.stop).toHaveBeenCalledOnce();
+    recognition.result('hello', 'world', 'again');
+    recognition.onend?.();
+    expect(commit).toHaveBeenCalledExactlyOnceWith('hello world again');
+    expect(manager.getSnapshot().phase).toBe('idle');
+  });
+  it('ignores late callbacks after cancellation and a new recording', () => {
+    manager.start('en', 'one', draft);
+    const lateEnd = recognition.onend;
+    const lateResult = recognition.onresult;
+    manager.cancel();
+    expect(recognition.abort).toHaveBeenCalledOnce();
+    recognition = new Recognition();
+    manager.start('zh', 'two', draft);
+    lateResult?.({ results: [{ isFinal: true, 0: { transcript: 'old' } }] });
+    lateEnd?.();
+    expect(commit).not.toHaveBeenCalled();
+    expect(manager.getSnapshot().text).toBe('');
+    expect(recognition.lang).toBe('zh-CN');
+  });
+  it('cancels a quick release before permission or onstart without later recording', () => {
+    manager.start('en', 'one', draft);
+    const lateStart = recognition.onstart;
+    manager.finish();
+    lateStart?.();
+    expect(recognition.abort).toHaveBeenCalledOnce();
+    expect(manager.getSnapshot().phase).toBe('idle');
+    vi.advanceTimersByTime(20000);
+    expect(manager.getSnapshot().phase).toBe('idle');
+  });
+  it.each(['not-allowed', 'network', 'audio-capture', 'no-speech'])('surfaces %s without modifying the draft', (error) => {
+    manager.start('en', 'one', draft);
+    recognition.onerror?.({ error });
+    expect(manager.getSnapshot().phase).toBe('error');
+    expect(recognition.abort).toHaveBeenCalledOnce();
+    expect(commit).not.toHaveBeenCalled();
+  });
+  it('commits confirmed text on interruption without a second insertion', () => {
+    manager.start('en', 'one', draft);
+    recognition.onstart?.();
+    recognition.result('keep this');
+    manager.interrupt();
+    expect(commit).toHaveBeenCalledExactlyOnceWith('keep this');
+    manager.cancel();
+    expect(commit).toHaveBeenCalledOnce();
+  });
+  it('times out startup and stopping and ends recording at 60 seconds', () => {
+    manager.start('en', 'one', draft);
+    vi.advanceTimersByTime(15000);
+    expect(manager.getSnapshot().error).toBe('timeout');
+    manager.start('en', 'one', draft);
+    recognition.onstart?.();
+    vi.advanceTimersByTime(60000);
+    expect(manager.getSnapshot().phase).toBe('stopping');
+    expect(recognition.stop).toHaveBeenCalledOnce();
+    vi.advanceTimersByTime(8000);
+    expect(manager.getSnapshot().error).toBe('timeout');
+  });
+  it('handles unsupported APIs and thrown starts', () => {
+    const unsupported = new ChatVoiceInputManager(() => null);
+    unsupported.start('en', 'one', draft);
+    expect(unsupported.getSnapshot().error).toBe('unsupported');
+    recognition.start.mockImplementation(() => { throw new Error('device'); });
+    manager.start('en', 'one', draft);
+    expect(manager.getSnapshot().error).toBe('failed');
+  });
+
+});
+
+describe('keyboard and page integration', () => {
+  const bind = (ctrl = false, alt = false) => useChatVoiceShortcutStore.getState().setShortcut({ code: 'KeyV', ctrl, meta: false, alt, shift: false });
+  const key = (type: string, options: KeyboardEventInit = {}) => new KeyboardEvent(type, { code: 'KeyV', bubbles: true, cancelable: true, ...options });
+  it('never steals paste, normal typing, or input-method composition', () => {
+    bind();
+    renderHook(() => useChatVoiceInput(manager, 'one', 'en', true, beginDraft));
+    const input = document.createElement('textarea'); document.body.append(input);
+    const typing = key('keydown');
+    const paste = key('keydown', { ctrlKey: true });
+    const composing = key('keydown', { isComposing: true });
+    act(() => { input.dispatchEvent(typing); input.dispatchEvent(paste); window.dispatchEvent(composing); });
+    expect(typing.defaultPrevented).toBe(false);
+    expect(paste.defaultPrevented).toBe(false);
+    expect(recognition.start).not.toHaveBeenCalled();
+    input.remove();
+  });
+  it('holds a configured combination and stops when a modifier is released', () => {
+    bind(true, true);
+    renderHook(() => useChatVoiceInput(manager, 'one', 'en', true, beginDraft));
+    act(() => { window.dispatchEvent(key('keydown', { ctrlKey: true, altKey: true })); recognition.onstart?.(); });
+    expect(recognition.start).toHaveBeenCalledOnce();
+    act(() => { window.dispatchEvent(key('keyup', { code: 'AltLeft', key: 'Alt' })); });
+    expect(recognition.stop).toHaveBeenCalledOnce();
+  });
+  it('does not register recording shortcuts in a mobile or disabled composer', () => {
+    bind();
+    renderHook(() => useChatVoiceInput(manager, 'one', 'en', false, beginDraft));
+    act(() => { window.dispatchEvent(key('keydown')); });
+    expect(recognition.start).not.toHaveBeenCalled();
+  });
+  it('cancels recording on context switch and unmount', () => {
+    const hook = renderHook(({ context }) => useChatVoiceInput(manager, context, 'en', true, beginDraft), { initialProps: { context: 'one' } });
+    act(() => { manager.start('en', 'one', draft); });
+    hook.rerender({ context: 'two' });
+    expect(recognition.abort).toHaveBeenCalledOnce();
+    expect(manager.getSnapshot().phase).toBe('idle');
+    act(() => { manager.start('en', 'two', draft); });
+    hook.unmount();
+    expect(recognition.abort).toHaveBeenCalledTimes(2);
+  });
+  it('rejects editing keys and persisted invalid shortcut definitions', () => {
+    expect(isVoiceShortcut({ code: 'KeyV', ctrl: true, meta: false, alt: false, shift: false })).toBe(false);
+    expect(isVoiceShortcut({ code: 'Enter', ctrl: false, meta: false, alt: false, shift: false })).toBe(false);
+    expect(isVoiceShortcut({ code: 'KeyV', ctrl: false, meta: false, alt: false, shift: false })).toBe(true);
+  });
+});

package/src/features/chat/features/conversation/hooks/use-chat-voice-input.ts

@@ -0,0 +1,52 @@
+import { useEffect, useSyncExternalStore } from 'react';
+import type { ChatComposerDictationSession } from '@nextclaw/agent-chat-ui';
+import type { ChatVoiceInputManager } from '@/features/chat/managers/chat-voice-input.manager';
+import { useChatVoiceShortcutStore } from '@/features/chat/stores/chat-voice-shortcut.store';
+
+export function useChatVoiceInput(manager: ChatVoiceInputManager, context: string, language: string,
+  keyboardEnabled: boolean, beginDraft: () => ChatComposerDictationSession | null) {
+  const snapshot = useSyncExternalStore(manager.subscribe, manager.getSnapshot, manager.getSnapshot);
+  const shortcut = useChatVoiceShortcutStore((state) => state.shortcut);
+  useEffect(() => {
+    if (!keyboardEnabled || !shortcut) return;
+    let held = false;
+    const keydown = (event: KeyboardEvent) => {
+      if (event.defaultPrevented || event.isComposing || event.repeat || event.code !== shortcut.code ||
+        event.ctrlKey !== shortcut.ctrl || event.metaKey !== shortcut.meta ||
+        event.altKey !== shortcut.alt || event.shiftKey !== shortcut.shift ||
+        !document.hasFocus()) return;
+      if (!['idle', 'ready'].includes(manager.getSnapshot().phase)) return;
+      const editable = event.target instanceof HTMLElement &&
+        (event.target.isContentEditable || event.target.closest('input, textarea, select, [contenteditable="true"], [role="textbox"]'));
+      if (editable && !shortcut.ctrl && !shortcut.meta && !shortcut.alt) return;
+      event.preventDefault();
+      held = true;
+      manager.start(language, context, beginDraft());
+    };
+    const keyup = (event: KeyboardEvent) => {
+      if (held && (event.code === shortcut.code || ['Alt', 'Control', 'Meta', 'Shift'].includes(event.key))) {
+        held = false; manager.finish();
+      }
+    };
+    window.addEventListener('keydown', keydown);
+    window.addEventListener('keyup', keyup);
+    return () => {
+      window.removeEventListener('keydown', keydown);
+      window.removeEventListener('keyup', keyup);
+      if (held) manager.cancel();
+    };
+  }, [manager, context, language, keyboardEnabled, beginDraft, shortcut]);
+  useEffect(() => {
+    const onVisibility = () => { if (document.hidden) manager.interrupt(); };
+    window.addEventListener('blur', manager.interrupt);
+    window.addEventListener('pagehide', manager.cancel);
+    document.addEventListener('visibilitychange', onVisibility);
+    return () => {
+      window.removeEventListener('blur', manager.interrupt);
+      window.removeEventListener('pagehide', manager.cancel);
+      document.removeEventListener('visibilitychange', onVisibility);
+      manager.cancel();
+    };
+  }, [manager, context]);
+  return snapshot;
+}

package/src/features/chat/features/input/utils/__tests__/chat-input-bar.utils.test.ts

@@ -438,16 +438,22 @@ describe('buildModelToolbarSelect selection', () => {
         ]
       },
       {
-        key: 'all-models',
-        label: 'All models',
+        key: 'provider-openai',
+        label: 'OpenAI',
         options: [
           {
             value: 'openai/gpt-5',
-            label: 'OpenAI/gpt-5'
-          },
+            label: 'gpt-5'
+          }
+        ]
+      },
+      {
+        key: 'provider-minimax',
+        label: 'MiniMax',
+        options: [
           {
             value: 'minimax/MiniMax-M2.7',
-            label: 'MiniMax/MiniMax-M2.7'
+            label: 'MiniMax-M2.7'
           }
         ]
       }
@@ -487,11 +493,12 @@ describe('buildModelToolbarSelect selection', () => {
     expect(select.groups?.map((group) => group.key)).toEqual([
       'favorite-models',
       'recent-models',
-      'all-models'
+      'provider-minimax'
     ]);
     expect(select.groups?.[0]?.options.map((option) => option.value)).toEqual(['openai/gpt-5']);
     expect(select.groups?.[1]?.options.map((option) => option.value)).toEqual(['anthropic/claude-sonnet-4']);
     expect(select.groups?.[2]?.options.map((option) => option.value)).toEqual(['minimax/MiniMax-M2.7']);
+    expect(select.groups?.[2]?.label).toBe('MiniMax');
     expect(select.optionAction).toMatchObject({
       kind: 'favorite',
       activeValues: ['openai/gpt-5'],

package/src/features/chat/features/input/utils/chat-input-toolbar.utils.ts

@@ -31,6 +31,22 @@ function buildDiscoveredModelGroups(options: ChatModelRecord[]) {
   return [...groups.values()];
 }
 
+function buildRemainingModelGroups(options: ChatModelRecord[], allModelsLabel: string) {
+  const groups = new Map<string, { key: string; label: string; options: Array<{ value: string; label: string }> }>();
+  for (const option of options) {
+    const separatorIndex = option.value.indexOf('/');
+    const providerKey = separatorIndex > 0 ? option.value.slice(0, separatorIndex) : "other";
+    const group = groups.get(providerKey) ?? {
+      key: `provider-${providerKey}`,
+      label: option.providerLabel.trim() || allModelsLabel,
+      options: [],
+    };
+    group.options.push({ value: option.value, label: option.modelLabel.trim() });
+    groups.set(providerKey, group);
+  }
+  return [...groups.values()];
+}
+
 export function toChatModelRecords(snapshotModels: ChatModelOption[]): ChatModelRecord[] {
   return snapshotModels.map((model) => ({
     value: model.value,
@@ -183,8 +199,9 @@ export function buildModelToolbarSelect({
   const remainingOptions = modelOptions.filter(
     (option) => !favoriteValueSet.has(option.value) && !recentValueSet.has(option.value),
   );
-  const optionGroups = favoriteOptions.length > 0 || recentOptions.length > 0
-    ? [
+  const groups = [
+    ...(favoriteOptions.length > 0
+      ? [
           {
             key: "favorite-models",
             label: texts.favoriteModelsLabel,
@@ -193,6 +210,10 @@ export function buildModelToolbarSelect({
               label: formatModelOptionLabel(option),
             })),
           },
+        ]
+      : []),
+    ...(recentOptions.length > 0
+      ? [
           {
             key: "recent-models",
             label: texts.recentModelsLabel,
@@ -201,16 +222,11 @@ export function buildModelToolbarSelect({
               label: formatModelOptionLabel(option),
             })),
           },
-          {
-            key: "all-models",
-            label: texts.allModelsLabel,
-            options: remainingOptions.map((option) => ({
-              value: option.value,
-              label: formatModelOptionLabel(option),
-            })),
-          },
-        ].filter((group) => group.options.length > 0)
-    : undefined;
+        ]
+      : []),
+    ...buildRemainingModelGroups(remainingOptions, texts.allModelsLabel),
+  ].filter((group) => group.options.length > 0);
+  const optionGroups = groups.length > 0 ? groups : undefined;
   const discoveryOptions = discoveredModelOptions ?? [];
 
   return {

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

@@ -1,4 +1,5 @@
-import type { NcpMessage } from "@nextclaw/ncp";
+import { NcpEventType, type NcpMessage } from "@nextclaw/ncp";
+import { DefaultNcpAgentConversationStateManager } from "@nextclaw/ncp-toolkit";
 import { describe, expect, it } from "vitest";
 import { buildChatMessageProcessSummary } from "@/features/chat/features/message/utils/chat-message-process-summary.utils";
 
@@ -29,6 +30,23 @@ const baseAssistantMessage = {
 } satisfies NcpMessage;
 
 describe("buildChatMessageProcessSummary", () => {
+  it("shows elapsed time from the real completed-message then run-finished event sequence", async () => {
+    const manager = new DefaultNcpAgentConversationStateManager();
+    await manager.dispatchBatch([
+      { type: NcpEventType.RunStarted, payload: { sessionId: "session-1", runId: "run-1" } },
+      { type: NcpEventType.MessageCompleted, payload: { sessionId: "session-1", message: baseAssistantMessage } },
+      {
+        type: NcpEventType.RunFinished,
+        payload: {
+          sessionId: "session-1", runId: "run-1", messageId: baseAssistantMessage.id,
+          startedAt: "2026-03-31T10:00:00.000Z", endedAt: "2026-03-31T10:03:51.000Z",
+        },
+      },
+    ]);
+    const message = manager.getSnapshot().messages[0]!;
+    expect(buildChatMessageProcessSummary({ message, processedLabel: "已处理" })?.label).toBe("已处理 3m 51s");
+  });
+
   it("does not invent duration when lifecycle timing is absent", () => {
     expect(
       buildChatMessageProcessSummary({

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

@@ -125,6 +125,16 @@ describe("chat message timeline visibility", () => {
     })).toBe(false);
     expect(isVisibleChatMessage(visibleMessage)).toBe(true);
   });
+
+  it("keeps a normal assistant reply visible when it explains the silent marker", () => {
+    expect(isVisibleChatMessage({
+      ...visibleMessage,
+      parts: [{
+        type: "text",
+        text: "空转 tick 调用一次服务，然后返回 `<noreply/>`，成本很低。",
+      }],
+    })).toBe(true);
+  });
 });
 
 describe("chat message continuation projection", () => {

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

@@ -242,10 +242,11 @@ it("preserves full generic tool args for the expanded body while keeping the hea
 
 it("keeps structured terminal results as structured data instead of raw json output", () => {
   const terminalResult = {
-    status: "completed",
-    command: "python3 -m http.server 8765",
-    aggregated_output: "",
-    exit_code: 0,
+    ok: true,
+    command: "nextclaw --version",
+    exitCode: 0,
+    stdout: "0.48.3\n",
+    stderr: "",
   };
 
   const adapted = adapt([
@@ -259,7 +260,7 @@ it("keeps structured terminal results as structured data instead of raw json out
             status: ToolInvocationStatus.RESULT,
             toolCallId: "call-terminal-result",
             toolName: "command_execution",
-            args: '{"command":"python3 -m http.server 8765"}',
+            args: '{"command":"nextclaw --version"}',
             result: terminalResult,
           },
         },
@@ -271,7 +272,7 @@ it("keeps structured terminal results as structured data instead of raw json out
     type: "tool-card",
     card: {
       toolName: "command_execution",
-      summary: "command: python3 -m http.server 8765",
+      summary: "command: nextclaw --version",
       output: undefined,
       outputData: terminalResult,
       statusTone: "success",

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

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

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

@@ -513,6 +513,26 @@ describe("useNcpAgentRuntime", () => {
 });
 
 describe("useNcpAgentRuntime commands and live stream", () => {
+  it("keeps the run active after message completion and settles immediately on the terminal event", async () => {
+    const client = new DeferredSendClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    const { result } = renderHook(() => useNcpAgentRuntime({ sessionId: "session-1", client, manager }));
+    await act(async () => {
+      await client.emit({ type: NcpEventType.RunStarted, payload: { sessionId: "session-1", runId: "run-1" } });
+      await client.emit({ type: NcpEventType.MessageCompleted, payload: {
+        sessionId: "session-1",
+        message: { id: "assistant-1", sessionId: "session-1", role: "assistant", status: "final", timestamp: now, parts: [{ type: "text", text: "Done" }] },
+      } });
+    });
+    await waitFor(() => expect(result.current.visibleMessages[0]?.status).toBe("final"));
+    expect(result.current.isRunning).toBe(true);
+    await act(async () => {
+      await client.emit({ type: NcpEventType.RunFinished, payload: { sessionId: "session-1", runId: "run-1", messageId: "assistant-1" } });
+    });
+    await waitFor(() => expect(result.current.isRunning).toBe(false));
+    expect(result.current.isSending).toBe(false);
+  });
+
   beforeEach(() => {
     vi.clearAllMocks();
   });

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

@@ -9,7 +9,9 @@ import {
 import { useChatSessionListStore } from "@/features/chat/stores/chat-session-list.store";
 
 const mocks = vi.hoisted(() => ({
+  confirm: vi.fn(),
   createSession: vi.fn(),
+  removeProject: vi.fn(),
   toggleProjectCollapsed: vi.fn(),
   toggleProjectPinned: vi.fn(),
 }));
@@ -19,6 +21,18 @@ vi.mock("@/features/chat/components/providers/chat-presenter.provider", () => ({
     chatSessionListManager: mocks,
   }),
 }));
+vi.mock("@/shared/hooks/use-projects", () => ({
+  useRemoveProject: () => ({
+    mutateAsync: mocks.removeProject,
+    isPending: false,
+  }),
+}));
+vi.mock("@/shared/hooks/use-confirm-dialog", () => ({
+  useConfirmDialog: () => ({
+    confirm: mocks.confirm,
+    ConfirmDialog: () => <div data-testid="confirm-dialog" />,
+  }),
+}));
 
 const projectGroup: ChatSidebarProjectGroup = {
   projectId: "project-analysis",
@@ -50,9 +64,10 @@ function LocationProbe() {
 function renderProjectGroups(
   isPinned = false,
   group: ChatSidebarProjectGroup = projectGroup,
+  initialPath = "/chat",
 ) {
   return render(
-    <MemoryRouter initialEntries={["/chat"]}>
+    <MemoryRouter initialEntries={[initialPath]}>
       <ChatSidebarProjectGroups
         groups={[{ ...group, isPinned }]}
         projectCronJobCountByRoot={new Map([[projectGroup.projectRoot, 2]])}
@@ -69,7 +84,11 @@ function renderProjectGroups(
 
 describe("ChatSidebarProjectGroups", () => {
   beforeEach(() => {
+    mocks.confirm.mockReset();
+    mocks.confirm.mockResolvedValue(true);
     mocks.createSession.mockReset();
+    mocks.removeProject.mockReset();
+    mocks.removeProject.mockResolvedValue(undefined);
     mocks.toggleProjectCollapsed.mockReset();
     mocks.toggleProjectPinned.mockReset();
     useChatSessionListStore.setState({
@@ -97,12 +116,16 @@ describe("ChatSidebarProjectGroups", () => {
     expect(projectRow?.className).toContain("hover:bg-gray-200/60");
     const projectContent = projectLink.parentElement;
     expect(projectContent?.classList.contains("pr-14")).toBe(false);
-    expect(projectContent?.className).toContain("group-hover/project:pr-14");
+    expect(projectContent?.className).toContain("group-hover/project:pr-20");
     expect(projectContent?.className).toContain(
-      "group-has-[[data-project-actions]:focus-within]/project:pr-14",
+      "group-has-[[data-project-actions]:focus-within]/project:pr-20",
+    );
+    expect(projectLink.querySelector("span")?.className).not.toContain(
+      "uppercase",
+    );
+    expect(projectLink.querySelector("span")?.className).toContain(
+      "text-[13px]",
     );
-    expect(projectLink.querySelector("span")?.className).not.toContain("uppercase");
-    expect(projectLink.querySelector("span")?.className).toContain("text-[13px]");
     expect(
       header.compareDocumentPosition(projectLink) &
         Node.DOCUMENT_POSITION_FOLLOWING,
@@ -159,7 +182,7 @@ describe("ChatSidebarProjectGroups", () => {
     expect(within(tooltip).getByText("2")).toBeTruthy();
   });
 
-  it("keeps project creation and pinning in one trailing action cluster", () => {
+  it("keeps project creation, pinning, and more actions in one trailing cluster", () => {
     renderProjectGroups();
 
     fireEvent.click(screen.getByLabelText("Pin project"));
@@ -168,6 +191,67 @@ describe("ChatSidebarProjectGroups", () => {
       "/tmp/analysis-project",
     );
     expect(screen.getByLabelText("New Task · analysis-project")).not.toBeNull();
+    const pinButton = screen.getByLabelText("Pin project");
+    const moreButton = screen.getByLabelText(
+      "More actions for analysis-project",
+    );
+    expect(moreButton.querySelector(".lucide-ellipsis-vertical")).not.toBeNull();
+    expect(
+      pinButton.compareDocumentPosition(moreButton) &
+        Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy();
+  });
+
+  it("removes a project from an ordinary more-actions menu after confirmation", async () => {
+    const user = userEvent.setup();
+    renderProjectGroups(
+      false,
+      projectGroup,
+      "/projects/project-analysis/overview",
+    );
+
+    await user.click(
+      screen.getByLabelText("More actions for analysis-project"),
+    );
+    const removeButton = await screen.findByRole("button", {
+      name: "Remove from project list",
+    });
+    expect(removeButton.className).not.toContain("text-destructive");
+    await user.click(removeButton);
+
+    await vi.waitFor(() =>
+      expect(mocks.confirm).toHaveBeenCalledWith(
+        expect.objectContaining({
+          description: expect.stringMatching(/local folder|本地目录/),
+          variant: "default",
+        }),
+      ),
+    );
+    await vi.waitFor(() =>
+      expect(mocks.removeProject).toHaveBeenCalledWith("project-analysis"),
+    );
+    await vi.waitFor(() =>
+      expect(screen.getByTestId("location").textContent).toBe("/projects"),
+    );
+  });
+
+  it("keeps the project when removal is cancelled from the menu", async () => {
+    mocks.confirm.mockResolvedValue(false);
+    const user = userEvent.setup();
+    renderProjectGroups();
+
+    await user.click(
+      screen.getByLabelText("More actions for analysis-project"),
+    );
+    await user.click(
+      await screen.findByRole("button", {
+        name: "Remove from project list",
+      }),
+    );
+
+    await vi.waitFor(() => expect(mocks.confirm).toHaveBeenCalledOnce());
+    expect(mocks.removeProject).not.toHaveBeenCalled();
+    expect(screen.getByRole("link", { name: "analysis-project" })).toBeTruthy();
   });
 
   it("uses the same pin control to show and clear the project pin state", () => {