Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

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.md
new file mode 100644
index 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.tsx
index 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>
<Button
type="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.tsx
index 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.tsx
index 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 {
<Button
type="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`, so
this 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 one
gesture wherever you are talking to an agent — and the same
toggle, 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.
compact
queueCount={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>
+ ) : (
<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"
+ 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.tsx
new file mode 100644
index 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.tsx
index 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.json
index 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.po
index 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.tsx
msgid "Stopping"
msgstr "Stopping"
diff --git a/packages/app/src/locales/pseudo/messages.json b/packages/app/src/locales/pseudo/messages.json
index 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.po
index 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.tsx
msgid "Stopping"
msgstr ""