@@ -1,11 +1,12 @@
-import { memo, useEffect, useRef } from 'react';
+import { memo, useCallback, useEffect, useRef } from 'react';
 import { useWatch } from 'react-hook-form';
 import { Button, TooltipAnchor } from '@librechat/client';
 import { ChevronDown, CornerDownLeft, TriangleAlert } from 'lucide-react';
 import AskUserQuestions from '~/components/Chat/Messages/Content/AskUserQuestions';
 import useAskAnswerMode from '~/hooks/Input/useAskAnswerMode';
 import AskOptions from '~/components/Chat/ask/options';
 import { useChatFormContext } from '~/Providers';
+import { isCancelKey } from '~/utils/shortcuts';
 import { useComposerOverlay } from './overlay';
 import { useLocalize } from '~/hooks';
 
@@ -32,20 +33,47 @@ function AskUserQuestionPopoverContent({
   textAreaRef?: React.RefObject<HTMLTextAreaElement>;
 }) {
   const ask = useAskAnswerMode(conversationId);
-  useComposerOverlay(conversationId, ask.popoverVisible);
+  const { collapse, popoverVisible } = ask;
+  useComposerOverlay(conversationId, popoverVisible);
 
-  if (!ask.popoverVisible || !ask.liveAsk) {
+  /**
+   * Escape from inside the popover does what it does from the composer: moves
+   * the question to the chat. Focus then returns to the composer, which a
+   * batch keeps disabled until the popover is gone, hence after the commit.
+   */
+  const refocusComposer = useRef(false);
+  const escapeToChat = useCallback(() => {
+    refocusComposer.current = true;
+    collapse();
+  }, [collapse]);
+  useEffect(() => {
+    if (popoverVisible || !refocusComposer.current) {
+      return;
+    }
+    refocusComposer.current = false;
+    textAreaRef?.current?.focus();
+  }, [popoverVisible, textAreaRef]);
+
+  if (!popoverVisible || !ask.liveAsk) {
     return null;
   }
 
   if (ask.liveAsk.questions != null && ask.liveAsk.questions.length > 0) {
-    return <AskUserQuestionsPopoverPanel ask={ask} />;
+    return <AskUserQuestionsPopoverPanel ask={ask} onEscape={escapeToChat} />;
   }
 
-  return <AskUserQuestionPopoverPanel ask={ask} textAreaRef={textAreaRef} />;
+  return (
+    <AskUserQuestionPopoverPanel ask={ask} textAreaRef={textAreaRef} onEscape={escapeToChat} />
+  );
 }
 
-function AskUserQuestionsPopoverPanel({ ask }: { ask: ReturnType<typeof useAskAnswerMode> }) {
+function AskUserQuestionsPopoverPanel({
+  ask,
+  onEscape,
+}: {
+  ask: ReturnType<typeof useAskAnswerMode>;
+  onEscape: () => void;
+}) {
   const { liveAsk, collapse } = ask;
   const questions = liveAsk?.questions;
   if (liveAsk == null || questions == null || questions.length === 0) {
@@ -62,6 +90,8 @@ function AskUserQuestionsPopoverPanel({ ask }: { ask: ReturnType<typeof useAskAn
           actionId={liveAsk.actionId}
           questions={questions}
           className="shrink-0"
+          focusOnArrival
+          onEscape={onEscape}
           headerAction={<MoveToChatButton onClick={collapse} />}
         />
       </div>
@@ -101,9 +131,11 @@ function MoveToChatButton({ onClick }: { onClick: () => void }) {
 function AskUserQuestionPopoverPanel({
   ask,
   textAreaRef,
+  onEscape,
 }: {
   ask: ReturnType<typeof useAskAnswerMode>;
   textAreaRef?: React.RefObject<HTMLTextAreaElement>;
+  onEscape: () => void;
 }) {
   const localize = useLocalize();
   const { control } = useChatFormContext();
@@ -165,7 +197,14 @@ function AskUserQuestionPopoverPanel({
           overflows it is unreachable by page scroll. */}
       <div
         className="popover border-border-light bg-surface-secondary rounded-theme-popover flex max-h-[60vh] flex-col border p-2 shadow-lg [view-transition-name:ask-question]"
-        onKeyDown={handlePopoverKeyDown}
+        onKeyDown={(e) => {
+          if (isCancelKey(e.nativeEvent) && !e.nativeEvent.isComposing) {
+            e.preventDefault();
+            onEscape();
+            return;
+          }
+          handlePopoverKeyDown(e);
+        }}
       >
         <div className="text-text-secondary flex shrink-0 items-start justify-between gap-2 p-1 pl-2">
           <div className="max-h-[24vh] min-w-0 overflow-y-auto pt-1">
 
@@ -0,0 +1,132 @@
+import React, { createRef } from 'react';
+import { RecoilRoot } from 'recoil';
+import { useForm, FormProvider } from 'react-hook-form';
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import type { Agents } from 'librechat-data-provider';
+import AskUserQuestionPopover from '../AskUserQuestionPopover';
+
+const mockCollapse = jest.fn();
+const mockHandlePopoverKeyDown = jest.fn();
+/** The popover is memoized, so visibility changes reach it the way the real
+ *  hook's state does: through a store it subscribes to. */
+const mockVisibility = {
+  visible: true,
+  listeners: new Set<() => void>(),
+  set(visible: boolean) {
+    this.visible = visible;
+    this.listeners.forEach((listener) => listener());
+  },
+  subscribe(listener: () => void) {
+    mockVisibility.listeners.add(listener);
+    return () => mockVisibility.listeners.delete(listener);
+  },
+};
+let mockQuestions: Agents.AskUserQuestionBatchItem[] | undefined;
+
+jest.mock('~/hooks', () => ({
+  useLocalize: () => (key: string) => key,
+}));
+
+jest.mock('~/components/Chat/Messages/Content/ApprovalContext', () => ({
+  useAskSubmitStatus: () => ({ getAskStatus: () => 'idle' }),
+  useResumeSubmit: () => ({ submitAskAnswer: jest.fn() }),
+}));
+
+jest.mock('../overlay', () => ({
+  useComposerOverlay: jest.fn(),
+}));
+
+jest.mock('~/Providers', () => ({
+  useChatFormContext: () => jest.requireActual('react-hook-form').useFormContext(),
+}));
+
+jest.mock('~/hooks/Input/useAskAnswerMode', () => ({
+  __esModule: true,
+  default: () => ({
+    popoverVisible: jest
+      .requireActual('react')
+      .useSyncExternalStore(mockVisibility.subscribe, () => mockVisibility.visible),
+    liveAsk: {
+      actionId: 'ask-1',
+      question: { question: 'Which environment?', options: [{ label: 'Staging', value: 's' }] },
+      questions: mockQuestions,
+    },
+    options: [{ label: 'Staging', value: 's' }],
+    selected: null,
+    checked: [],
+    multiSelect: false,
+    locked: false,
+    errored: false,
+    toggleChecked: jest.fn(),
+    canSubmit: false,
+    submit: jest.fn(),
+    submitOption: jest.fn(),
+    skip: jest.fn(),
+    collapse: mockCollapse,
+    handlePopoverKeyDown: mockHandlePopoverKeyDown,
+  }),
+}));
+
+function Host({ textAreaRef }: { textAreaRef: React.RefObject<HTMLTextAreaElement> }) {
+  const methods = useForm({ defaultValues: { text: '' } });
+  return (
+    <RecoilRoot>
+      <FormProvider {...methods}>
+        <textarea ref={textAreaRef} aria-label="Composer" />
+        <AskUserQuestionPopover conversationId="conversation-1" textAreaRef={textAreaRef} />
+      </FormProvider>
+    </RecoilRoot>
+  );
+}
+
+describe('AskUserQuestionPopover Escape', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockVisibility.visible = true;
+    mockQuestions = undefined;
+  });
+
+  /** Escape on `target`, then the popover closes; returns the composer. */
+  const escapeThenClose = (target: () => HTMLElement) => {
+    const textAreaRef = createRef<HTMLTextAreaElement>();
+    render(<Host textAreaRef={textAreaRef} />);
+    fireEvent.keyDown(target(), { key: 'Escape' });
+    act(() => mockVisibility.set(false));
+    return textAreaRef.current;
+  };
+
+  test('moves a single question to the chat and returns focus to the composer', () => {
+    const composer = escapeThenClose(() => screen.getByRole('button', { name: /Staging/ }));
+    expect(mockCollapse).toHaveBeenCalledTimes(1);
+    expect(mockHandlePopoverKeyDown).not.toHaveBeenCalled();
+    expect(composer).toHaveFocus();
+  });
+
+  test('moves a batch to the chat and returns focus to the composer', () => {
+    mockQuestions = [
+      { id: 'window', question: 'Which time window?' },
+      { id: 'region', question: 'Which region?' },
+    ];
+    const composer = escapeThenClose(() =>
+      screen.getByRole('textbox', { name: /Which time window/ }),
+    );
+    expect(mockCollapse).toHaveBeenCalledTimes(1);
+    expect(composer).toHaveFocus();
+  });
+
+  test('leaves an Escape that cancels an IME composition alone', () => {
+    render(<Host textAreaRef={createRef<HTMLTextAreaElement>()} />);
+    fireEvent.keyDown(screen.getByRole('button', { name: /Staging/ }), {
+      key: 'Escape',
+      isComposing: true,
+    });
+    expect(mockCollapse).not.toHaveBeenCalled();
+  });
+
+  test('passes other keys through to the popover shortcuts', () => {
+    render(<Host textAreaRef={createRef<HTMLTextAreaElement>()} />);
+    fireEvent.keyDown(screen.getByRole('button', { name: /Staging/ }), { key: '1' });
+    expect(mockHandlePopoverKeyDown).toHaveBeenCalledTimes(1);
+    expect(mockCollapse).not.toHaveBeenCalled();
+  });
+});
@@ -2,14 +2,25 @@ import { useContext, useMemo, useState } from 'react';
 import { Button, TextareaAutosize, TooltipAnchor } from '@librechat/client';
 import { ChevronDown, MessageCircleQuestion, TriangleAlert } from 'lucide-react';
 import type { Agents } from 'librechat-data-provider';
+import type { KeyboardEvent } from 'react';
+import type { ComposerBindings } from '~/hooks/Input/useComposerBindings';
+import { isCancelKey, isReboundSubmitChord, resolveComposerKeyDown } from '~/utils/shortcuts';
 import { useApprovalContext, useAskSubmitStatus, useResumeSubmit } from './ApprovalContext';
 import { splitOtherOption, ASK_USER_DECLINED_ANSWER } from '~/utils/approval';
+import { useOptionalChatSurface } from '~/components/Chat/Subagents/surface';
+import { cn, forceResize, insertTextAtCursor } from '~/utils';
 import useAskAnswerMode from '~/hooks/Input/useAskAnswerMode';
 import AskOptions from '~/components/Chat/ask/options';
 import { ChatContext } from '~/Providers/ChatContext';
 import AskUserQuestions from './AskUserQuestions';
 import { useLocalize } from '~/hooks';
-import { cn } from '~/utils';
+
+/** Stock preferences for a card rendered outside a chat surface. */
+const NO_HOST_BINDINGS: ComposerBindings = {
+  shortcutsEnabled: true,
+  submitOverride: undefined,
+  yieldedChords: new Set(),
+};
 
 /**
  * Renders an `ask_user_question` pause: the prompt, optional description, any
@@ -81,6 +92,7 @@ function AskUserQuestionsCard({
       <AskUserQuestions
         actionId={actionId}
         questions={questions}
+        focusOnArrival={live}
         headerAction={
           onExpand != null && (
             <TooltipAnchor
@@ -122,6 +134,10 @@ function AskUserQuestionSingle({
   const { submitAskAnswer } = useResumeSubmit();
   const [answer, setAnswer] = useState(() => getAskAnswerDraft(actionId));
   const [localChecked, setLocalChecked] = useState<number[]>([]);
+  const surface = useOptionalChatSurface();
+  const enterToSend = surface?.enterToSend ?? false;
+  const { shortcutsEnabled, submitOverride, yieldedChords } =
+    surface?.composerBindings ?? NO_HOST_BINDINGS;
   /**
    * The composer popover is the primary answer surface — while it's VISIBLE
    * for this pause, rendering the card too duplicates the question. The card
@@ -216,6 +232,59 @@ function AskUserQuestionSingle({
     submitAskAnswer(actionId, values.join(', '));
   };
 
+  /**
+   * The answer box follows the composer's Enter table, so the user's
+   * Enter-to-send preference and any rebound submit chord apply here too. The
+   * run is paused on this question rather than generating, so it resolves as
+   * idle: Ctrl/Cmd+Enter must submit the answer, not reach the during-run
+   * steer/queue actions.
+   */
+  const handleAnswerKeyDown = (e: KeyboardEvent<HTMLTextAreaElement>) => {
+    const isComposing = e.nativeEvent.isComposing || e.key === 'Process' || e.keyCode === 229;
+    if (!isComposing && isReboundSubmitChord(e.nativeEvent, { shortcutsEnabled, submitOverride })) {
+      e.preventDefault();
+      if (canSubmit && !locked) {
+        submitCombined();
+      }
+      return;
+    }
+    const action = resolveComposerKeyDown(e.nativeEvent, {
+      isComposing,
+      isSubmitting: false,
+      allowSubmitWhileGenerating: false,
+      hasDuringRunModifier: false,
+      shortcutsEnabled,
+      enterToSend,
+      submitOverride,
+      yieldedChords,
+    });
+    if (action === 'none') {
+      return;
+    }
+    e.preventDefault();
+    if (action === 'newline') {
+      insertTextAtCursor(e.currentTarget, '\n');
+      forceResize(e.currentTarget);
+      return;
+    }
+    if (action === 'submit' && canSubmit && !locked) {
+      submitCombined();
+    }
+  };
+
+  /** Escape skips, but only before anything is entered, so a stray Escape
+   *  cannot discard an answer and resume the run. */
+  const handleCardKeyDown = (e: KeyboardEvent<HTMLDivElement>) => {
+    if (!isCancelKey(e.nativeEvent) || e.nativeEvent.isComposing) {
+      return;
+    }
+    if (locked || trimmed.length > 0 || (multiSelect && checkedIndices.length > 0)) {
+      return;
+    }
+    e.preventDefault();
+    handleSkip();
+  };
+
   /**
    * The live card shares its view-transition-name with the popover panel, so
    * collapse/expand morphs one surface into the other. The placeholder copy
@@ -233,6 +302,7 @@ function AskUserQuestionSingle({
         isLivePause && !showPlaceholder && '[view-transition-name:ask-question]',
       )}
       aria-hidden={showPlaceholder || undefined}
+      onKeyDown={handleCardKeyDown}
     >
       <div className="text-text-secondary flex items-start justify-between gap-2">
         <div className="min-w-0 pt-1">
@@ -284,6 +354,7 @@ function AskUserQuestionSingle({
           setAnswerValue(e.target.value);
           setAskAnswerDraft(actionId, e.target.value);
         }}
+        onKeyDown={handleAnswerKeyDown}
         minRows={2}
         maxRows={12}
         placeholder={otherLabel ?? localize('com_ui_your_answer')}