Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
Collapse the composer Stop and Send into one action button (#3071)
sarah34b7a9617054
diff --git a/.changeset/acp-composer-single-action-slot.md b/.changeset/acp-composer-single-action-slot.mdnew file mode 100644index 000000000..585e40f68--- /dev/null+++ b/.changeset/acp-composer-single-action-slot.md@@ -0,0 +1,5 @@+---+"@inkeep/open-knowledge": patch+---++The agent composer now shows one action button instead of Stop and Send at the same time. While the agent is working the button is Stop; as soon as you start typing it becomes Send, and your message queues behind the current turn the way it always has. This matches how other agent chats behave and keeps a single clear action in the corner of the composer. Because Stop is hidden while you have a draft, pressing Escape in the composer now stops the agent, and your draft is kept so you can still queue it. Hovering Stop shows the shortcut. A stop that hasn't taken effect yet keeps showing its spinner even if you keep typing, so you can always tell whether the agent heard you.diff --git a/packages/app/src/components/ComposerAddContextMenu.tsx b/packages/app/src/components/ComposerAddContextMenu.tsxindex da8cc1171..9f7741acc 100644--- a/packages/app/src/components/ComposerAddContextMenu.tsx+++ b/packages/app/src/components/ComposerAddContextMenu.tsx@@ -63,9 +63,10 @@ export function ComposerAddContextMenu({<DropdownMenuTrigger asChild><Buttontype="button"- // No `size` in compact mode: the height and padding come from the- // classes below, matching the settings trigger exactly.- {...(compact ? {} : { size: 'icon' as const })}+ // Compact rides `icon-xs` so the trigger is square, matching the+ // settings trigger beside it; the class below only restates the height+ // and swaps the radius.+ size={compact ? 'icon-xs' : undefined}variant="ghost"aria-label={t`Add context to this message`}data-testid="composer-add-context"@@ -73,7 +74,7 @@ export function ComposerAddContextMenu({// not anything is attached — the input keeps every remaining pixel.className={cn('shrink-0 text-muted-foreground hover:text-foreground',- compact ? 'h-6 rounded-md px-2' : 'size-8',+ compact ? 'h-6 rounded-md' : 'size-8',)}><Plus className={compact ? 'size-3.5' : 'size-4'} />diff --git a/packages/app/src/components/acp/ThreadView.dom.test.tsx b/packages/app/src/components/acp/ThreadView.dom.test.tsxindex 6ac08c8e6..2766a1076 100644--- a/packages/app/src/components/acp/ThreadView.dom.test.tsx+++ b/packages/app/src/components/acp/ThreadView.dom.test.tsx@@ -40,12 +40,13 @@ const setMode = vi.fn((_threadId: string, _modeId: string) => {});const prompt = vi.fn((_threadId: string, _content: string) => {});const editQueued = vi.fn((_threadId: string, _id: string, _content: string) => {});const removeQueued = vi.fn((_threadId: string, _id: string) => {});+const cancel = vi.fn((_threadId: string) => {});vi.doMock('@/lib/acp/thread-client', () => ({getAgentThreadClient: () => ({respondPermission,respondRuntimeConsent: () => {},- cancel: () => {},+ cancel,prompt,editQueued,removeQueued,@@ -84,6 +85,23 @@ vi.doMock('@/components/acp/AgentMarkdown', () => ({AgentMarkdown: ({ text }: { text: string }) => <div>{text}</div>,}));+// The comment-queue surface the composer's `+` drives. Stubbed to a single+// always-available item so a test can attach a batch and assert how the action+// slot reacts; the real store needs a loaded project.+vi.doMock('@/comments/comment-chips', () => ({+ useQueuedComments: () => [{ id: 'c1' }],+ composeCommentBatchInstruction: (_items: unknown, typed: string) =>+ typed === '' ? 'batch instruction' : typed,+}));++vi.doMock('@/comments/queue-attachment', () => ({+ prepareQueuedComments: async () => [{ id: 'c1' }],+}));++vi.doMock('@/comments/store', () => ({+ refresh: async () => undefined,+}));+const { ThreadView } = await import('./ThreadView');// Not mocked — the settings popover writes real remembered picks through it.const { agentSettingsKey, getRememberedAgentConfig, getRememberedAgentMode } = await import(@@ -166,6 +184,7 @@ afterEach(() => {prompt.mockClear();editQueued.mockClear();removeQueued.mockClear();+ cancel.mockClear();model = null;});@@ -1001,20 +1020,174 @@ describe('ThreadView raw input', () => {});describe('ThreadView message queue', () => {- test('mid-turn the composer offers Stop AND a live Send that queues the draft', () => {+ test('mid-turn the action slot holds Stop until a draft exists, then yields to Send', () => {model = makeModel({ turnActive: true });render(<ThreadView info={makeInfo({ status: 'running' })} />);+ // Empty draft: Stop owns the slot outright — no competing Send button.expect(screen.getByTestId('agent-thread-cancel')).toBeTruthy();+ expect(screen.queryByTestId('agent-thread-send')).toBeNull();++ fireEvent.change(screen.getByTestId('agent-thread-composer'), {+ target: { value: 'queued while running' },+ });++ expect(screen.queryByTestId('agent-thread-cancel')).toBeNull();const send = screen.getByTestId('agent-thread-send');expect(send.getAttribute('aria-label')).toBe('Queue message');- expect((send as HTMLButtonElement).disabled).toBe(true); // empty draft+ expect((send as HTMLButtonElement).disabled).toBe(false);++ fireEvent.click(send);+ expect(prompt).toHaveBeenCalledWith('thread-1', 'queued while running');+ });++ test('Escape cancels the turn while a draft holds the action slot', () => {+ model = makeModel({ turnActive: true });+ render(<ThreadView info={makeInfo({ status: 'running' })} />);++ const composer = screen.getByTestId('agent-thread-composer');+ fireEvent.change(composer, { target: { value: 'typed mid-turn' } });+ // Stop is gone, so this is the only remaining way to cancel.+ expect(screen.queryByTestId('agent-thread-cancel')).toBeNull();++ fireEvent.keyDown(composer, { key: 'Escape' });+ expect(cancel).toHaveBeenCalledWith('thread-1');+ // The draft survives the cancel — it's still queueable against the next turn.+ expect((composer as HTMLTextAreaElement).value).toBe('typed mid-turn');+ });++ test('a pending cancel keeps the Stopping spinner even as the user types', () => {+ model = makeModel({ turnActive: true });+ render(<ThreadView info={makeInfo({ status: 'running' })} />);+ fireEvent.click(screen.getByTestId('agent-thread-cancel'));fireEvent.change(screen.getByTestId('agent-thread-composer'), {- target: { value: 'queued while running' },+ target: { value: 'typed while stopping' },+ });++ const stopping = screen.getByTestId('agent-thread-cancel');+ expect(stopping.getAttribute('aria-label')).toBe('Stopping');+ expect((stopping as HTMLButtonElement).disabled).toBe(true);+ expect(screen.queryByTestId('agent-thread-send')).toBeNull();+ });++ test('outside a turn the slot is Send, disabled only by an empty draft', () => {+ model = makeModel({ turnActive: false });+ render(<ThreadView info={makeInfo({ status: 'ready' })} />);++ expect(screen.queryByTestId('agent-thread-cancel')).toBeNull();+ const send = screen.getByTestId('agent-thread-send');+ expect(send.getAttribute('aria-label')).toBe('Send');+ expect((send as HTMLButtonElement).disabled).toBe(true);++ fireEvent.change(screen.getByTestId('agent-thread-composer'), {+ target: { value: 'idle send' },+ });+ expect((screen.getByTestId('agent-thread-send') as HTMLButtonElement).disabled).toBe(false);+ });++ test('Escape stays scoped to the composer and does not cancel from the transcript', () => {+ model = makeModel({ turnActive: true });+ render(<ThreadView info={makeInfo({ status: 'running' })} />);++ fireEvent.change(screen.getByTestId('agent-thread-composer'), {+ target: { value: 'typed, then clicked away' },});++ fireEvent.keyDown(screen.getByTestId('agent-thread-transcript'), { key: 'Escape' });+ expect(cancel).not.toHaveBeenCalled();++ // Escape is dismiss-shaped, so a panel-wide binding would let a stray press+ // kill a running turn. The accepted cost is this state: a draft hides Stop,+ // and cancelling means clicking back into the composer or clearing the draft.+ // Pinned so widening the scope is a deliberate change, not an accident.+ fireEvent.keyDown(screen.getByTestId('agent-thread-composer'), { key: 'Escape' });+ expect(cancel).toHaveBeenCalledWith('thread-1');+ });++ test('an attached comment batch counts as sendable, so the slot yields Stop', async () => {+ const user = userEvent.setup();+ model = makeModel({ turnActive: true });+ render(<ThreadView info={makeInfo({ status: 'running' })} />);++ // Empty draft mid-turn: Stop owns the slot.+ expect(screen.getByTestId('agent-thread-cancel')).toBeTruthy();++ await user.click(screen.getByTestId('composer-add-context'));+ await user.click(screen.getByTestId('composer-add-context-queue'));++ // The batch is a message on its own, so the slot must offer to send it even+ // though the draft is still empty. Keying the slot on the draft alone left+ // Stop mounted with a sendable batch attached and no way to dispatch it.+ expect(await screen.findByTestId('agent-thread-send')).toBeTruthy();+ expect(screen.queryByTestId('agent-thread-cancel')).toBeNull();+ expect((screen.getByTestId('agent-thread-send') as HTMLButtonElement).disabled).toBe(false);++ // And the slot's Send actually dispatches the batch: `submit` folds the+ // attached items through `composeCommentBatchInstruction` rather than+ // sending the empty draft it can see.fireEvent.click(screen.getByTestId('agent-thread-send'));- expect(prompt).toHaveBeenCalledWith('thread-1', 'queued while running');+ expect(prompt).toHaveBeenCalledWith('thread-1', 'batch instruction');+ });++ test('Escape cancels with an empty draft too, while Stop is also on screen', () => {+ model = makeModel({ turnActive: true });+ render(<ThreadView info={makeInfo({ status: 'running' })} />);++ expect(screen.getByTestId('agent-thread-cancel')).toBeTruthy();+ fireEvent.keyDown(screen.getByTestId('agent-thread-composer'), { key: 'Escape' });+ expect(cancel).toHaveBeenCalledWith('thread-1');+ });++ test('Escape is a no-op while a cancel is already pending', () => {+ model = makeModel({ turnActive: true });+ render(<ThreadView info={makeInfo({ status: 'running' })} />);++ fireEvent.click(screen.getByTestId('agent-thread-cancel'));+ expect(cancel).toHaveBeenCalledTimes(1);++ fireEvent.keyDown(screen.getByTestId('agent-thread-composer'), { key: 'Escape' });+ expect(cancel).toHaveBeenCalledTimes(1);+ });++ test('Escape outside a turn does not fire a cancel', () => {+ model = makeModel({ turnActive: false });+ render(<ThreadView info={makeInfo({ status: 'ready' })} />);++ const composer = screen.getByTestId('agent-thread-composer');+ fireEvent.change(composer, { target: { value: 'idle draft' } });+ fireEvent.keyDown(composer, { key: 'Escape' });++ expect(cancel).not.toHaveBeenCalled();+ });++ test('Stop advertises the Escape shortcut, so it is learned before it is needed', async () => {+ const user = userEvent.setup();+ model = makeModel({ turnActive: true });+ render(<ThreadView info={makeInfo({ status: 'running' })} />);++ await user.hover(screen.getByTestId('agent-thread-cancel'));++ const tooltip = await screen.findByRole('tooltip');+ expect(tooltip.textContent).toContain('Esc');+ });++ test('Escape in the queued-message editor exits editing without cancelling the turn', () => {+ model = makeModel({ turnActive: true });+ render(+ <ThreadView+ info={makeInfo({+ status: 'running',+ queue: [{ id: 'q1', content: 'original text', ts: 1 }],+ })}+ />,+ );++ fireEvent.click(screen.getByTestId('agent-thread-queued-edit'));+ fireEvent.keyDown(screen.getByTestId('agent-thread-queued-input'), { key: 'Escape' });++ expect(screen.queryByTestId('agent-thread-queued-input')).toBeNull();+ expect(cancel).not.toHaveBeenCalled();});test('queued messages render between transcript and composer with a remove control', () => {diff --git a/packages/app/src/components/acp/ThreadView.tsx b/packages/app/src/components/acp/ThreadView.tsxindex e31bafb34..db71e2d2d 100644--- a/packages/app/src/components/acp/ThreadView.tsx+++ b/packages/app/src/components/acp/ThreadView.tsx@@ -664,7 +664,7 @@ function AgentSettingsPopover({ info }: { info: ThreadInfo }): ReactNode {<Buttontype="button"variant="ghost"- className="h-6 max-w-48 gap-1 rounded-md px-2 text-xs"+ className="h-6 max-w-48 gap-1 rounded-md pl-1.5 pr-1! text-xs"aria-label={accentTooltip}data-testid="agent-thread-settings">@@ -2029,6 +2029,13 @@ function ThreadComposer({const queue = info.queue ?? [];+ // What the action slot keys off. An attached comment batch is a message on its+ // own — the comments carry their own requests — so an empty draft beside one+ // still has something to send. Both the Stop/Send choice and Send's disabled+ // state read this, or the two disagree and the slot offers Stop while a+ // sendable batch sits attached.+ const hasSendableContent = draft.trim() !== '' || commentsAttached;+return (<div className="p-2">{queue.length > 0 && !archived ? (@@ -2053,6 +2060,16 @@ function ThreadComposer({if (event.key === 'Enter' && !event.shiftKey) {event.preventDefault();onSubmit();+ } else if (event.key === 'Escape' && turnActive && !cancelPending) {+ // Deliberately field-scoped, not panel-wide. Sendable content hides+ // Stop, so Escape is the cancel path while composing — but Escape+ // is a dismiss-shaped key, and binding it panel-wide would let a+ // stray press kill a running turn with no undo. The accepted cost:+ // leave content in the composer, click away, and neither Stop nor+ // Escape is reachable until you click back or clear it. Judged rare+ // enough to accept over a broader binding or a second Stop.+ event.preventDefault();+ onCancel();}}}rows={1}@@ -2092,7 +2109,6 @@ function ThreadComposer({other. The right cluster keeps its own spacing via `ml-auto`, sothis doesn't move it. */}<div className="flex items-center gap-0.5">- <AgentSettingsPopover info={info} />{/* The same `+` the Ask AI composer carries, so "add context" is onegesture wherever you are talking to an agent — and the sametoggle, so it is also one gesture to take it back off. The batch@@ -2101,7 +2117,7 @@ function ThreadComposer({nothing resolves. */}<ComposerAddContextMenu// This bar is `h-6` / `text-xs` controls (the settings trigger to- // its left); a composer-sized button would tower over them.+ // its right); a composer-sized button would tower over them.compactqueueCount={queuedComments.length}queueAttached={commentsAttached}@@ -2114,43 +2130,54 @@ function ThreadComposer({}}onRemoveQueue={() => onAttachComments(null)}/>+ <AgentSettingsPopover info={info} /></div><div className="ml-auto flex items-center gap-1.5">{usagePercent !== null && usage?.used !== undefined && usage?.size !== undefined ? (<ContextUsageRing used={usage.used} size={usage.size} percent={usagePercent} />) : null}- {turnActive ? (+ {/* One action slot, never two competing buttons. Mid-turn it holds+ Stop until there is something to send, then yields so it can+ queue — the convention every agent chat with a queue follows.+ `cancelPending` outranks the content check: a cancel can hang for+ CANCEL_STALL_MS, and typing during that window must not replace+ the only signal that the stop was heard. */}+ {turnActive && (cancelPending || !hasSendableContent) ? (+ <Tooltip>+ <TooltipTrigger asChild>+ <Button+ type="button"+ size="icon-sm"+ className="rounded-lg"+ disabled={cancelPending}+ onClick={onCancel}+ aria-label={cancelPending ? t`Stopping` : t`Stop`}+ data-testid="agent-thread-cancel"+ >+ {cancelPending ? (+ <Loader2 className="size-3.5 animate-spin" aria-hidden="true" />+ ) : (+ <Square className="size-3 fill-current" aria-hidden="true" />+ )}+ </Button>+ </TooltipTrigger>+ {/* Teaches the Escape binding while Stop is visible, so it's+ already known in the draft-present state where it's hidden. */}+ <TooltipContent side="top">{t`Stop (Esc)`}</TooltipContent>+ </Tooltip>+ ) : (<Buttontype="button"size="icon-sm"className="rounded-lg"- disabled={cancelPending}- onClick={onCancel}- aria-label={cancelPending ? t`Stopping` : t`Stop`}- data-testid="agent-thread-cancel"+ disabled={!(canPrompt || canQueue) || !hasSendableContent}+ onClick={onSubmit}+ aria-label={canQueue ? t`Queue message` : t`Send`}+ data-testid="agent-thread-send">- {cancelPending ? (- <Loader2 className="size-3.5 animate-spin" aria-hidden="true" />- ) : (- <Square className="size-3 fill-current" aria-hidden="true" />- )}+ <ArrowUp className="size-4" aria-hidden="true" /></Button>- ) : null}- <Button- type="button"- size="icon-sm"- className="rounded-lg"- // An attached batch IS a message — the comments carry their own- // requests, so an empty draft alongside them is a send, not a- // no-op. Gating on the draft alone left the button dead with a- // full queue attached.- disabled={!(canPrompt || canQueue) || (draft.trim() === '' && !commentsAttached)}- onClick={onSubmit}- aria-label={canQueue ? t`Queue message` : t`Send`}- data-testid="agent-thread-send"- >- <ArrowUp className="size-4" aria-hidden="true" />- </Button>+ )}</div></div></div>diff --git a/packages/app/src/components/ui/sidebar-escape.dom.test.tsx b/packages/app/src/components/ui/sidebar-escape.dom.test.tsxnew file mode 100644index 000000000..94f7f2ea6--- /dev/null+++ b/packages/app/src/components/ui/sidebar-escape.dom.test.tsx@@ -0,0 +1,82 @@+import { cleanup, render, screen } from '@testing-library/react';+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';+import { SidebarProvider } from './sidebar';++// Below LEFT_COLLAPSE_THRESHOLD (1024), so `partition` resolves to 'below' and+// the Escape-dismisses-the-sidebar listener is live. Above it the listener never+// subscribes and there is nothing to collide with.+const NARROW_VIEWPORT = 800;++let originalInnerWidth: number;++beforeEach(() => {+ originalInnerWidth = window.innerWidth;+ Object.defineProperty(window, 'innerWidth', {+ configurable: true,+ writable: true,+ value: NARROW_VIEWPORT,+ });+});++afterEach(() => {+ Object.defineProperty(window, 'innerWidth', {+ configurable: true,+ writable: true,+ value: originalInnerWidth,+ });+ cleanup();+});++function renderNarrowSidebar(onOpenChange: (open: boolean) => void) {+ return render(+ <SidebarProvider open onOpenChange={onOpenChange}>+ <textarea data-testid="field" aria-label="a text field" />+ {/* Stand-in for the ProseMirror document surface, which is contentEditable. */}+ <div data-testid="editor" contentEditable suppressContentEditableWarning />+ <div data-testid="plain">not a text surface</div>+ </SidebarProvider>,+ );+}++describe('sidebar Escape dismissal', () => {+ test('Escape from a plain element still collapses the sidebar', () => {+ const onOpenChange = vi.fn();+ renderNarrowSidebar(onOpenChange);++ screen+ .getByTestId('plain')+ .dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));++ expect(onOpenChange).toHaveBeenCalledWith(false);+ });++ test('Escape from the document editor still collapses the sidebar', () => {+ const onOpenChange = vi.fn();+ renderNarrowSidebar(onOpenChange);++ // contentEditable is deliberately outside the guard. The editor binds no+ // Escape of its own, and dismissing chrome from the main work surface is+ // intended: an e2e clicks into the ProseMirror surface and then presses+ // Escape expecting the sidebar to close. Guarding contentEditable broke it.+ screen+ .getByTestId('editor')+ .dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));++ expect(onOpenChange).toHaveBeenCalledWith(false);+ });++ test('Escape inside a form control belongs to that control, not the sidebar', () => {+ const onOpenChange = vi.fn();+ renderNarrowSidebar(onOpenChange);++ // The listener is capture-phase on window, so it sees this before any+ // field-scoped handler can preventDefault — the target is the only signal+ // available to tell the two apart. Without the guard, stopping an agent turn+ // with Escape in the composer would also collapse unrelated chrome.+ screen+ .getByTestId('field')+ .dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));++ expect(onOpenChange).not.toHaveBeenCalled();+ });+});diff --git a/packages/app/src/components/ui/sidebar.tsx b/packages/app/src/components/ui/sidebar.tsxindex 16b4c9369..809f63046 100644--- a/packages/app/src/components/ui/sidebar.tsx+++ b/packages/app/src/components/ui/sidebar.tsx@@ -194,6 +194,20 @@ function SidebarProvider({const onEscape = (event: KeyboardEvent) => {if (event.key !== 'Escape') return;if (isOverlayLayerOpen()) return;+ // Escape inside a form control belongs to that control — it is where+ // Escape carries a field-local meaning (revert, clear, cancel the edit),+ // and the agent composer's cancel-the-turn binding lives on one. Capture+ // phase means this runs before the field's own handler, so+ // `defaultPrevented` is always false here and the target is the only+ // available signal.+ //+ // contentEditable is deliberately NOT included. The document editor is+ // this app's main work surface, it binds no Escape of its own, and+ // dismissing chrome from it is the intended behavior.+ const target = event.target as HTMLElement | null;+ if (target && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA')) {+ return;+ }setOpen(false);};window.addEventListener('keydown', onEscape, { capture: true });diff --git a/packages/app/src/locales/en/messages.json b/packages/app/src/locales/en/messages.jsonindex 466600732..ec7484906 100644--- a/packages/app/src/locales/en/messages.json+++ b/packages/app/src/locales/en/messages.json@@ -1499,6 +1499,7 @@"RGCCrg": ["Copy share link"],"RGkNeJ": ["Initialize a starter pack"],"RJ3a8Z": ["Looking for <0>", ["lookingForUrl"], "</0>."],+ "RLYckQ": ["Stop (Esc)"],"RMQe3p": ["Are you sure you want to convert this file into a template? The original file will be deleted. This action cannot be undone."],diff --git a/packages/app/src/locales/en/messages.po b/packages/app/src/locales/en/messages.poindex 4fbeb8023..5b637a115 100644--- a/packages/app/src/locales/en/messages.po+++ b/packages/app/src/locales/en/messages.po@@ -9265,6 +9265,10 @@ msgstr "Still loading"msgid "Stop"msgstr "Stop"+#: src/components/acp/ThreadView.tsx+msgid "Stop (Esc)"+msgstr "Stop (Esc)"+#: src/components/acp/ThreadView.tsxmsgid "Stopping"msgstr "Stopping"diff --git a/packages/app/src/locales/pseudo/messages.json b/packages/app/src/locales/pseudo/messages.jsonindex 3550578ec..5186075fa 100644--- a/packages/app/src/locales/pseudo/messages.json+++ b/packages/app/src/locales/pseudo/messages.json@@ -1499,6 +1499,7 @@"RGCCrg": ["Ćōƥŷ śĥàŕē ĺĩńķ"],"RGkNeJ": ["Ĩńĩţĩàĺĩźē à śţàŕţēŕ ƥàćķ"],"RJ3a8Z": ["Ĺōōķĩńĝ ƒōŕ <0>", ["lookingForUrl"], "</0>."],+ "RLYckQ": ["Śţōƥ (Ēść)"],"RMQe3p": ["Àŕē ŷōũ śũŕē ŷōũ ŵàńţ ţō ćōńvēŕţ ţĥĩś ƒĩĺē ĩńţō à ţēḿƥĺàţē? Ţĥē ōŕĩĝĩńàĺ ƒĩĺē ŵĩĺĺ ƀē ďēĺēţēď. Ţĥĩś àćţĩōń ćàńńōţ ƀē ũńďōńē."],diff --git a/packages/app/src/locales/pseudo/messages.po b/packages/app/src/locales/pseudo/messages.poindex 3b2e55ae9..6a3d03ec9 100644--- a/packages/app/src/locales/pseudo/messages.po+++ b/packages/app/src/locales/pseudo/messages.po@@ -9261,6 +9261,10 @@ msgstr ""msgid "Stop"msgstr ""+#: src/components/acp/ThreadView.tsx+msgid "Stop (Esc)"+msgstr ""+#: src/components/acp/ThreadView.tsxmsgid "Stopping"msgstr ""