diff --git a/api/server/controllers/AuthController.spec.js b/api/server/controllers/AuthController.spec.js
index 2f4b6985bc3..e0f0892bf1d 100644
--- a/api/server/controllers/AuthController.spec.js
+++ b/api/server/controllers/AuthController.spec.js
@@ -856,17 +856,15 @@ describe('refreshController – OpenID path', () => {
     expect(res.status).toHaveBeenCalledWith(403);
   });
 
-  it('requires sign-in without publishing tokens when the persisted session disappeared', async () => {
+  it('refreshes with the cookie token when the persisted session expired', async () => {
     req.session.reload = jest.fn((callback) => callback(new Error('failed to load session')));
 
     await refreshController(req, res);
 
-    expect(clearOpenIDAuthTokens).toHaveBeenCalled();
-    expect(res.status).toHaveBeenCalledWith(401);
-    expect(res.send).toHaveBeenCalledWith({ code: 'OPENID_SESSION_MISSING' });
-    expect(setOpenIDAuthTokens).not.toHaveBeenCalled();
-    expect(storeOpenIDSession).not.toHaveBeenCalled();
-    expect(getRefreshTokenBridge).not.toHaveBeenCalled();
+    expect(clearOpenIDAuthTokens).not.toHaveBeenCalled();
+    expect(setOpenIDAuthTokens).toHaveBeenCalled();
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.send).not.toHaveBeenCalledWith({ code: 'OPENID_SESSION_MISSING' });
   });
 
   it('does not classify a session store outage as a missing session', async () => {
diff --git a/client/src/components/Chat/Input/DuringRunSendButton.tsx b/client/src/components/Chat/Input/DuringRunSendButton.tsx
index ea84300e756..0d0902e385a 100644
--- a/client/src/components/Chat/Input/DuringRunSendButton.tsx
+++ b/client/src/components/Chat/Input/DuringRunSendButton.tsx
@@ -1,8 +1,8 @@
 import React, { forwardRef, useMemo } from 'react';
 import { useRecoilValue } from 'recoil';
 import { useWatch } from 'react-hook-form';
-import { SendActions, SendIcon } from '@librechat/client';
 import { Zap, Clock, OctagonPause, ZapOff } from 'lucide-react';
+import { composerSubmitClasses, SendActions, SendIcon } from '@librechat/client';
 import type { SendAction } from '@librechat/client';
 import type { Control } from 'react-hook-form';
 import type { ComposerKeyContext, KeyChordSource } from '~/utils/shortcuts';
@@ -10,7 +10,6 @@ import type { SteeringControls } from '~/hooks/Chat/useSteering';
 import { isMacPlatform, resolveComposerKeyDown } from '~/utils/shortcuts';
 import useComposerBindings from '~/hooks/Input/useComposerBindings';
 import { useLocalize } from '~/hooks';
-import { cn } from '~/utils';
 import store from '~/store';
 
 /** The rows, the popover and the chord chips are shared with every other chat
@@ -175,9 +174,7 @@ const DuringRunSendButton = React.memo(
             aria-label={label}
             id="during-run-send-button"
             disabled={!content || props.disabled === true}
-            className={cn(
-              'size-theme-control rounded-theme-control-round bg-text-primary p-theme-compact text-text-primary outline-offset-4 transition-all duration-theme-normal disabled:cursor-not-allowed disabled:text-text-secondary disabled:opacity-10',
-            )}
+            className={composerSubmitClasses()}
             data-testid="during-run-send-button"
             data-during-run-action={primary}
             type="submit"
diff --git a/client/src/components/Chat/Input/SendButton.tsx b/client/src/components/Chat/Input/SendButton.tsx
index f4c855d8533..5f286840bbf 100644
--- a/client/src/components/Chat/Input/SendButton.tsx
+++ b/client/src/components/Chat/Input/SendButton.tsx
@@ -1,8 +1,8 @@
 import React, { forwardRef } from 'react';
 import { useWatch } from 'react-hook-form';
-import { SendIcon, TooltipAnchor } from '@librechat/client';
+import { composerSubmitClasses, SendIcon, TooltipAnchor } from '@librechat/client';
 import type { Control } from 'react-hook-form';
-import { cn, isSubmittableMessage } from '~/utils';
+import { isSubmittableMessage } from '~/utils';
 import { useLocalize } from '~/hooks';
 
 type SendButtonProps = {
@@ -24,9 +24,7 @@ const SubmitButton = React.memo(
             aria-label={localize('com_nav_send_message')}
             id="send-button"
             disabled={props.disabled}
-            className={cn(
-              'size-theme-control rounded-theme-control-round bg-text-primary p-theme-compact text-text-primary outline-offset-4 transition-all duration-theme-normal disabled:cursor-not-allowed disabled:text-text-secondary disabled:opacity-10',
-            )}
+            className={composerSubmitClasses()}
             data-testid="send-button"
             type="submit"
           >
diff --git a/client/src/components/Chat/Input/StopButton.tsx b/client/src/components/Chat/Input/StopButton.tsx
index 29845444489..b3556f7e699 100644
--- a/client/src/components/Chat/Input/StopButton.tsx
+++ b/client/src/components/Chat/Input/StopButton.tsx
@@ -1,7 +1,6 @@
 import { memo } from 'react';
-import { TooltipAnchor } from '@librechat/client';
+import { composerSubmitClasses, TooltipAnchor } from '@librechat/client';
 import { useLocalize } from '~/hooks';
-import { cn } from '~/utils';
 
 export default memo(function StopButton({
   stop,
@@ -19,9 +18,7 @@ export default memo(function StopButton({
         <button
           type="button"
           data-testid="stop-generation-button"
-          className={cn(
-            'size-theme-control rounded-theme-control-round bg-text-primary p-theme-compact text-text-primary outline-offset-4 transition-all duration-theme-normal disabled:cursor-not-allowed disabled:text-text-secondary disabled:opacity-10',
-          )}
+          className={composerSubmitClasses()}
           aria-label={localize('com_nav_stop_generating')}
           onClick={(e) => {
             setShowStopButton(false);
diff --git a/client/src/components/Chat/Input/__tests__/appearanceTokens.spec.ts b/client/src/components/Chat/Input/__tests__/appearanceTokens.spec.ts
index 4e9aa1379c6..f6c54294df5 100644
--- a/client/src/components/Chat/Input/__tests__/appearanceTokens.spec.ts
+++ b/client/src/components/Chat/Input/__tests__/appearanceTokens.spec.ts
@@ -5,12 +5,13 @@ const inputRoot = join(__dirname, '..');
 const source = (file: string): string => readFileSync(join(inputRoot, file), 'utf8');
 
 const themedControls = [
-  ['SendButton.tsx', ['size-theme-control', 'rounded-theme-control-round', 'p-theme-compact']],
-  ['StopButton.tsx', ['size-theme-control', 'rounded-theme-control-round', 'p-theme-compact']],
-  [
-    'DuringRunSendButton.tsx',
-    ['size-theme-control', 'rounded-theme-control-round', 'p-theme-compact'],
-  ],
+  /** The submit slot's three faces share one recipe, which owns the coarse-pointer
+   *  tap-target floor as well as the geometry; its tokens are asserted where it
+   *  lives (`composer.spec.ts`). Copying the class string back into any of them
+   *  would take that floor off a phone silently, so the recipe is what is checked. */
+  ['SendButton.tsx', ['composerSubmitClasses()']],
+  ['StopButton.tsx', ['composerSubmitClasses()']],
+  ['DuringRunSendButton.tsx', ['composerSubmitClasses()']],
   ['InterruptSteerButton.tsx', ['size-theme-control', 'rounded-theme-control-round']],
   ['AudioRecorder.tsx', ['size="theme"', 'shape="theme"']],
   /** Controls that draw their shape from `composerControlClasses()` prove it by
diff --git a/client/src/hooks/Chat/__tests__/useNewChat.spec.ts b/client/src/hooks/Chat/__tests__/useNewChat.spec.ts
index ce9df1bb364..82ad2f879d9 100644
--- a/client/src/hooks/Chat/__tests__/useNewChat.spec.ts
+++ b/client/src/hooks/Chat/__tests__/useNewChat.spec.ts
@@ -7,6 +7,7 @@ const mockNewConversation = jest.fn();
 const mockClearMessagesCache = jest.fn();
 const mockInvalidateQueries = jest.fn();
 const mockClearAllDrafts = jest.fn();
+const mockClearFilesDraft = jest.fn();
 const mockDeleteFiles = jest.fn();
 const mockScheduleRetainedRetry = jest.fn();
 
@@ -78,6 +79,7 @@ jest.mock('~/hooks/useNewConvo', () => ({
 jest.mock('~/utils', () => ({
   clearMessagesCache: (...args: unknown[]) => mockClearMessagesCache(...args),
   clearAllDrafts: (...args: unknown[]) => mockClearAllDrafts(...args),
+  clearFilesDraft: (...args: unknown[]) => mockClearFilesDraft(...args),
   getNewConversationDraftId: (index = 0) => (index === 0 ? 'new' : `new:${index}`),
   getPendingDraftId: (index = 0) => (index === 0 ? 'pending' : `pending:${index}`),
   getComposerDraftId: (index = 0, conversationId?: string | null) => {
@@ -260,26 +262,36 @@ describe('useNewChat', () => {
     expect(mockNewConversation).toHaveBeenCalledTimes(1);
   });
 
-  it('drops the unsaved-chat draft before the reset restores from it', () => {
+  it('drops the unsaved-chat attachments before the reset restores from them', () => {
     const { result } = renderHook(() => useNewChat());
 
     act(() => result.current.startNewChat());
 
-    expect(mockClearAllDrafts).toHaveBeenCalledWith('new');
-    expect(mockClearAllDrafts.mock.invocationCallOrder[0]).toBeLessThan(
+    expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
+    expect(mockClearFilesDraft.mock.invocationCallOrder[0]).toBeLessThan(
       mockNewConversation.mock.invocationCallOrder[0],
     );
   });
 
-  it('drops only its own pane unsaved-chat draft', () => {
-    const { result } = renderHook(() => useNewChat({ index: 1 }));
+  /** The reset is also how a user gets back to an unsaved chat they typed in and left, and the
+   * restore that puts an unwanted paste back is the same one that puts the message back. */
+  it('keeps what was typed in the unsaved chat', () => {
+    const { result } = renderHook(() => useNewChat());
 
     act(() => result.current.startNewChat());
 
-    expect(mockClearAllDrafts).toHaveBeenCalledWith('new:1');
     expect(mockClearAllDrafts).not.toHaveBeenCalledWith('new');
   });
 
+  it('drops only its own pane unsaved-chat attachments', () => {
+    const { result } = renderHook(() => useNewChat({ index: 1 }));
+
+    act(() => result.current.startNewChat());
+
+    expect(mockClearFilesDraft).toHaveBeenCalledWith('new:1');
+    expect(mockClearFilesDraft).not.toHaveBeenCalledWith('new');
+  });
+
   it('deletes the draft uploads a draft-saving user is discarding with the draft', () => {
     mockState.saveDrafts = true;
     mockState.filesDraft = {
@@ -315,7 +327,7 @@ describe('useNewChat', () => {
       ],
     });
     expect(mockDeleteFiles.mock.invocationCallOrder[0]).toBeLessThan(
-      mockClearAllDrafts.mock.invocationCallOrder[0],
+      mockClearFilesDraft.mock.invocationCallOrder[0],
     );
   });
 
@@ -490,7 +502,7 @@ describe('useNewChat', () => {
     act(() => result.current.startNewChat());
 
     expect(mockDeleteFiles).not.toHaveBeenCalled();
-    expect(mockClearAllDrafts).not.toHaveBeenCalledWith('new');
+    expect(mockClearFilesDraft).not.toHaveBeenCalledWith('new');
     expect(mockClearAllDrafts).toHaveBeenCalledWith('pending');
   });
 
@@ -895,7 +907,7 @@ describe('useNewChat', () => {
     act(() => result.current.startNewChat());
 
     expect(mockClearAllDrafts).toHaveBeenCalledWith('pending');
-    expect(mockClearAllDrafts).toHaveBeenCalledWith('new');
+    expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
   });
 
   it('deletes pending-draft uploads before clearing them', () => {
@@ -944,7 +956,7 @@ describe('useNewChat', () => {
 
     expect(mockDeleteFiles).not.toHaveBeenCalled();
     expect(mockClearAllDrafts).not.toHaveBeenCalledWith('pending');
-    expect(mockClearAllDrafts).toHaveBeenCalledWith('new');
+    expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
   });
 
   it('spares a reattached file from a retained deletion retry', async () => {
diff --git a/client/src/hooks/Chat/useNewChat.ts b/client/src/hooks/Chat/useNewChat.ts
index 564a3afe123..4f109400de8 100644
--- a/client/src/hooks/Chat/useNewChat.ts
+++ b/client/src/hooks/Chat/useNewChat.ts
@@ -9,6 +9,7 @@ import type { FilesDraft } from '~/utils';
 import {
   beginRetainedDeletionPass,
   clearAllDrafts,
+  clearFilesDraft,
   clearMessagesCache,
   clearRetainedFileDeletion,
   failedFileIdsFrom,
@@ -299,10 +300,13 @@ export default function useNewChat({
   const startNewChat = useCallback(() => {
     clearMessagesCache(queryClient, conversationId);
     queryClient.invalidateQueries([QueryKeys.messages]);
-    /** `newConversation` empties the composer, but the unsaved-chat draft key outlives it and
-     * `useAutoSave` restores from that key on the way in, so an unsent paste came back on every
-     * later new chat. Dropping the key first makes an explicit new chat an actual clean slate,
-     * for the text draft and its attachments alike. Per-conversation drafts are untouched.
+    /** The unsaved-chat draft key outlives the reset and `useAutoSave` restores from it on the way
+     * in, so an unsent paste came back on every later new chat. Its attachments are dropped here to
+     * make an explicit new chat a clean slate; its text is deliberately kept, because the restore
+     * is also what puts a draft back when the user simply leaves the unsaved chat and returns, and
+     * clearing it made that the one composer that forgot what had been typed in it. Nothing else is
+     * gained by clearing it: unlike an attachment there is no upload behind it to leave dangling.
+     * Per-conversation drafts are untouched either way.
      *
      * With draft saving on, `newConversation` deliberately leaves the draft's files alive
      * because a draft normally keeps them restorable; discarding the draft removes the only
@@ -442,8 +446,11 @@ export default function useNewChat({
     if (isFilesDraftOwnedByThisTab(pendingDraft)) {
       clearAllDrafts(pendingId);
     }
+    /** Attachments only: the uploads behind them have just been deleted, so restoring the chips
+     * would reference files that are gone, while the typed message is what the user expects to
+     * find again on the way back into the unsaved chat. */
     if (isFilesDraftOwnedByThisTab(idleDraft)) {
-      clearAllDrafts(draftId);
+      clearFilesDraft(draftId);
     }
     const discardedFileIds = Array.from(
       new Set([
diff --git a/client/src/hooks/Input/useAutoSave.spec.ts b/client/src/hooks/Input/useAutoSave.spec.ts
index 62cc492a7a2..ce3730e5659 100644
--- a/client/src/hooks/Input/useAutoSave.spec.ts
+++ b/client/src/hooks/Input/useAutoSave.spec.ts
@@ -422,6 +422,183 @@ describe('useAutoSave — debounced autosave', () => {
   });
 });
 
+describe('useAutoSave — typing as a run finishes', () => {
+  /** Real storage for these, because the loss is in what the record holds at the moment the key
+   * changes: a mock that answers every read with the same string cannot express it. */
+  const actualUtils = jest.requireActual('~/utils');
+
+  const getInputListener = (textAreaRef: React.RefObject<HTMLTextAreaElement>) =>
+    (textAreaRef.current!.addEventListener as unknown as jest.Mock).mock.calls.find(
+      ([event]) => event === 'input',
+    )![1] as (e: unknown) => void;
+
+  /** Types into the composer the way the browser does: the value is already there when the event
+   * fires, so a debounced write reads it whether or not the event carried it. */
+  const type = (textAreaRef: React.RefObject<HTMLTextAreaElement>, value: string) => {
+    textAreaRef.current!.value = value;
+    getInputListener(textAreaRef)({ target: { value } });
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    mockGetDraft.mockImplementation(actualUtils.getDraft);
+    mockSetDraft.mockImplementation(actualUtils.setDraft);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    /** Hand the rest of the suite its stubs back. An implementation set here outlives the block,
+     * and a real `setDraft` leaking into a later test writes records that test never asked for. */
+    mockGetDraft.mockReset();
+    mockSetDraft.mockReset();
+  });
+
+  /** The reported bug. The composer is keyed under PENDING while a run streams and under the
+   * conversation once it ends, and the key change tore off whatever the 25ms debounce had not
+   * written yet: the pending record still held the previous flush, run end migrated that record,
+   * and the restore put it back over the composer. Every keystroke since the last flush was
+   * silently rolled back mid-sentence. */
+  it('keeps the keystrokes the debounce had not written when the run ends', () => {
+    const textAreaRef = makeTextAreaRef();
+    const { rerender } = renderHook(
+      ({ isSubmitting }: { isSubmitting: boolean }) =>
+        useAutoSave({
+          isSubmitting,
+          conversationId: 'convo-1',
+          textAreaRef,
+          files: new Map(),
+          setFiles: jest.fn(),
+        }),
+      { initialProps: { isSubmitting: true } },
+    );
+
+    act(() => {
+      type(textAreaRef, 'my follow up');
+      jest.advanceTimersByTime(50);
+    });
+
+    /** Still typing when the response lands, inside the debounce window. */
+    act(() => {
+      type(textAreaRef, 'my follow up question');
+      rerender({ isSubmitting: false });
+    });
+
+    expect(mockSetValue).toHaveBeenLastCalledWith('text', 'my follow up question');
+    expect(actualUtils.getDraft('convo-1')).toBe('my follow up question');
+  });
+
+  it('keeps the whole message when the run ends before anything was written', () => {
+    const textAreaRef = makeTextAreaRef();
+    const { rerender } = renderHook(
+      ({ isSubmitting }: { isSubmitting: boolean }) =>
+        useAutoSave({
+          isSubmitting,
+          conversationId: 'convo-1',
+          textAreaRef,
+          files: new Map(),
+          setFiles: jest.fn(),
+        }),
+      { initialProps: { isSubmitting: true } },
+    );
+
+    act(() => {
+      type(textAreaRef, 'a whole sentence typed quickly');
+      rerender({ isSubmitting: false });
+    });
+
+    expect(mockSetValue).toHaveBeenLastCalledWith('text', 'a whole sentence typed quickly');
+  });
+
+  /** A draft of one character is deliberately not persisted, so the record cannot speak for the
+   * composer here. The composer still can, and it is what the user is looking at. */
+  it('keeps a single character typed as the run ends', () => {
+    const textAreaRef = makeTextAreaRef();
+    const { rerender } = renderHook(
+      ({ isSubmitting }: { isSubmitting: boolean }) =>
+        useAutoSave({
+          isSubmitting,
+          conversationId: 'convo-1',
+          textAreaRef,
+          files: new Map(),
+          setFiles: jest.fn(),
+        }),
+      { initialProps: { isSubmitting: true } },
+    );
+
+    act(() => {
+      type(textAreaRef, 'k');
+      rerender({ isSubmitting: false });
+    });
+
+    expect(mockSetValue).toHaveBeenLastCalledWith('text', 'k');
+  });
+
+  /** The same key change in the other direction. `useSubmitMessage` asks and then resets the form
+   * in one handler, so the composer is already empty when the render that flips to PENDING lands:
+   * the write flushed on the way out records the emptiness. Were it to record the sent text, run
+   * end would migrate it straight back into the composer as a duplicate of the message. */
+  it('does not keep the sent text as a draft when submitting mid-keystroke', () => {
+    const textAreaRef = makeTextAreaRef();
+    const { rerender } = renderHook(
+      ({ isSubmitting }: { isSubmitting: boolean }) =>
+        useAutoSave({
+          isSubmitting,
+          conversationId: 'convo-1',
+          textAreaRef,
+          files: new Map(),
+          setFiles: jest.fn(),
+        }),
+      { initialProps: { isSubmitting: false } },
+    );
+
+    act(() => {
+      type(textAreaRef, 'sent message');
+    });
+
+    /** Submit: `ask` then `methods.reset()`, batched into the render that starts the run. */
+    act(() => {
+      textAreaRef.current!.value = '';
+      rerender({ isSubmitting: true });
+    });
+
+    expect(actualUtils.getDraft('convo-1')).toBe('');
+    expect(actualUtils.getDraft(Constants.PENDING_CONVO)).toBe('');
+  });
+
+  /** The other side of the same key change, and the reason the in-flight write was dropped rather
+   * than flushed: a steer consumes the composer and clears it programmatically, and run end must
+   * not put the just-sent text back. An empty composer has nothing to defend, so the record wins. */
+  it('does not resurrect text a steer consumed as the run ended', () => {
+    const textAreaRef = makeTextAreaRef();
+    const { rerender } = renderHook(
+      ({ isSubmitting }: { isSubmitting: boolean }) =>
+        useAutoSave({
+          isSubmitting,
+          conversationId: 'convo-1',
+          textAreaRef,
+          files: new Map(),
+          setFiles: jest.fn(),
+        }),
+      { initialProps: { isSubmitting: true } },
+    );
+
+    act(() => {
+      type(textAreaRef, 'steered message');
+      jest.advanceTimersByTime(50);
+    });
+
+    /** The steer took the text and emptied the composer, and dropped the pending draft with it. */
+    act(() => {
+      actualUtils.clearAllDrafts(Constants.PENDING_CONVO);
+      type(textAreaRef, '');
+      rerender({ isSubmitting: false });
+    });
+
+    expect(mockSetValue).toHaveBeenLastCalledWith('text', '');
+    expect(actualUtils.getDraft('convo-1')).toBe('');
+  });
+});
+
 describe('useAutoSave — side-by-side pending drafts', () => {
   const pane0PendingId = Constants.PENDING_CONVO;
   const pane1PendingId = `${Constants.PENDING_CONVO}:1`;
diff --git a/client/src/hooks/Input/useAutoSave.ts b/client/src/hooks/Input/useAutoSave.ts
index f6d46fd9ed1..b088d0c5f2f 100644
--- a/client/src/hooks/Input/useAutoSave.ts
+++ b/client/src/hooks/Input/useAutoSave.ts
@@ -264,8 +264,15 @@ export const useAutoSave = ({
       if (textArea) {
         textArea.removeEventListener('input', eventListener);
       }
-      handleInputFast.cancel();
-      handleInputSlow.cancel();
+      /** Land the write instead of dropping it. This runs whenever the draft key changes and when
+       * the composer goes away, and a keystroke inside the debounce window has nothing else to
+       * persist it: cancelling here is what tore the end off a message being typed as a run
+       * finished, since the key moves from PENDING to the conversation at that moment and the
+       * record left behind was one flush old. Flushing is safe for the case the cancel was
+       * protecting — `saveLatest` reads the composer at flush time, so a steer that consumed the
+       * text and emptied the composer flushes the emptiness, not the message it just sent. */
+      handleInputFast.flush();
+      handleInputSlow.flush();
     };
   }, [activeStorageId, saveDrafts, textAreaRef]);
 
@@ -344,10 +351,17 @@ export const useAutoSave = ({
           nextConversationId = pendingDraftId;
         } else if (pendingOwned) {
           pendingDestinationRef.current = null;
-          // Move the pending text draft to the new conversationId, falling back to the current
-          // text area value when there was no pending draft to carry over
-          if (!migrateTextDraft(pendingDraftId, conversationId) && textAreaRef?.current?.value) {
-            setDraft({ id: conversationId, value: textAreaRef.current.value });
+          /** Move the pending text draft to the new conversationId, then let the composer correct
+           * it. Both describe the same composer and the record is a debounced copy of it, so when
+           * they disagree the record is simply older, and restoring it would roll the user's last
+           * keystrokes back mid-sentence. `persistExact` because a one-character message is still
+           * the user's message, and the ordinary threshold would refuse to keep it. An empty
+           * composer defers to the record instead: a steer consumes the text and clears the
+           * composer programmatically, and run end must not undo that. */
+          migrateTextDraft(pendingDraftId, conversationId);
+          const liveText = textAreaRef?.current?.value ?? '';
+          if (liveText !== '' && getDraft(conversationId) !== liveText) {
+            setDraft({ id: conversationId, value: liveText, persistExact: true });
           }
           filesDraftId = migrateFilesDraft(pendingDraftId, conversationId);
         } else {
diff --git a/client/src/utils/drafts.spec.ts b/client/src/utils/drafts.spec.ts
index b951eaaaa37..1cc6e6ae869 100644
--- a/client/src/utils/drafts.spec.ts
+++ b/client/src/utils/drafts.spec.ts
@@ -4,6 +4,7 @@ import {
   applyPendingPastesToDraft,
   clearAllDrafts,
   clearComposerDrafts,
+  clearFilesDraft,
   decodeBase64,
   encodeBase64,
   resolvePendingPasteInsertStart,
@@ -796,6 +797,73 @@ describe('browser tab ownership of unsaved-chat drafts', () => {
   });
 });
 
+describe('clearFilesDraft', () => {
+  const newChatKey = getNewConversationDraftId();
+
+  beforeEach(() => {
+    localStorage.clear();
+    sessionStorage.clear();
+  });
+
+  it('discards the attachments and keeps the text', () => {
+    setDraft({ id: newChatKey, value: 'half-written message' });
+    setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
+
+    clearFilesDraft(newChatKey);
+
+    expect(getFilesDraft(newChatKey).fileIds).toEqual([]);
+    expect(getDraft(newChatKey)).toBe('half-written message');
+  });
+
+  it('keeps this tab claim on the text it left behind', () => {
+    /** `setFilesDraft` drops the whole record once nothing is attached, and that record is the
+     * only ownership stamp the shared text draft has: without it another tab's New Chat would be
+     * free to clear text this tab is still holding. */
+    setDraft({ id: newChatKey, value: 'half-written message' });
+    setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
+
+    clearFilesDraft(newChatKey);
+
+    expect(getFilesDraft(newChatKey).tabId).toBe(getBrowserTabId());
+  });
+
+  /** The reset empties the file map, and `useAutoSave`'s attachment effect then writes the draft
+   * with nothing in it. That write used to delete the record this helper had just re-stamped, so
+   * the preserved text sat unowned until the next keystroke and another live tab finishing a
+   * new-chat run could clear it as though nobody were holding it. */
+  it('keeps the claim through the empty-map write the reset triggers', () => {
+    setDraft({ id: newChatKey, value: 'half-written message' });
+    setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
+
+    clearFilesDraft(newChatKey);
+    /** What the attachment effect writes once the composer's file map is empty. */
+    setFilesDraft(newChatKey, { fileIds: [], pastedTextIds: [], pendingPastes: {} });
+
+    expect(getFilesDraft(newChatKey).tabId).toBe(getBrowserTabId());
+    expect(getDraft(newChatKey)).toBe('half-written message');
+  });
+
+  it('leaves no claim behind when there was no text to hold', () => {
+    setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
+
+    clearFilesDraft(newChatKey);
+
+    expect(localStorage.getItem(`${LocalStorageKeys.FILES_DRAFT}${newChatKey}`)).toBeNull();
+  });
+
+  it('refuses a record another live tab owns', () => {
+    markTabLive('other-tab');
+    localStorage.setItem(
+      `${LocalStorageKeys.FILES_DRAFT}${newChatKey}`,
+      JSON.stringify({ fileIds: ['other-tab-file'], tabId: 'other-tab' }),
+    );
+
+    clearFilesDraft(newChatKey);
+
+    expect(getFilesDraft(newChatKey).fileIds).toEqual(['other-tab-file']);
+  });
+});
+
 describe('migrateFilesDraft', () => {
   beforeEach(() => {
     localStorage.clear();
diff --git a/client/src/utils/drafts.ts b/client/src/utils/drafts.ts
index 2191c15d039..facd6ec1072 100644
--- a/client/src/utils/drafts.ts
+++ b/client/src/utils/drafts.ts
@@ -889,6 +889,17 @@ export const setFilesDraft = (id: string, draft: FilesDraft): void => {
     pendingPasteEntries.length === 0 &&
     (draft.pastedTextIds?.length ?? 0) === 0
   ) {
+    /** Nothing attached, but on a shared key this record is also the only thing saying whose text
+     * is stored there, and dropping it leaves that text unowned for another tab to clear.
+     * `useAutoSave` rewrites the draft with an empty file map on every reset and every composer
+     * mount, so a claim that did not survive this branch barely survived at all. The text itself
+     * is the condition, exactly as in `releaseComposerDraftTab`: with none, the claim is residue
+     * and the record still goes. */
+    const holdsText = (getLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id}`) ?? '') !== '';
+    if (tabId != null && holdsText && isSharedComposerDraftId(id)) {
+      setLocalStorageItem(key, JSON.stringify({ fileIds: [], tabId }));
+      return;
+    }
     removeLocalStorageItem(key);
     return;
   }
@@ -1246,6 +1257,21 @@ export const setDraft = ({
 export const getDraft = (id?: string): string | null =>
   decodeBase64((getLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id ?? ''}`) ?? '') || '');
 
+/** Discards a key's attachments while leaving its text where it is. New Chat deletes the uploads
+ * the draft was holding, so restoring those chips would put back a file the server no longer has;
+ * a typed message has no such resource behind it, and losing it is what made an unsaved chat the
+ * one composer whose draft did not survive leaving and coming back.
+ *
+ * Written as an empty draft rather than a direct delete so the claim rule lives in one place:
+ * `setFilesDraft` keeps a shared key's stamp while text is stored under it and drops the record
+ * otherwise, which is also what the autosave write that follows this one has to do. */
+export const clearFilesDraft = (id: string): void => {
+  if (!mayClearComposerDrafts(id)) {
+    return;
+  }
+  setFilesDraft(id, { fileIds: [], pendingPastes: {} });
+};
+
 /**
  * Draft-key prefix for a live `ask_user_question` answer phase. While the
  * composer doubles as the free-form answer box, its autosave switches to a key
diff --git a/packages/api/src/auth/openid/errors.spec.ts b/packages/api/src/auth/openid/errors.spec.ts
index 2cf196d2090..d1b6ba4860e 100644
--- a/packages/api/src/auth/openid/errors.spec.ts
+++ b/packages/api/src/auth/openid/errors.spec.ts
@@ -1,4 +1,4 @@
-import { isOpenIDSessionMissingError } from './errors';
+import { isOpenIDSessionMissingError, reloadOpenIDSessionIfPersisted } from './errors';
 
 describe('isOpenIDSessionMissingError', () => {
   it('recognizes the express-session missing record error', () => {
@@ -14,3 +14,35 @@ describe('isOpenIDSessionMissingError', () => {
     expect(isOpenIDSessionMissingError(error)).toBe(false),
   );
 });
+
+describe('reloadOpenIDSessionIfPersisted', () => {
+  it('reports a persisted session that reloaded', async () => {
+    await expect(
+      reloadOpenIDSessionIfPersisted({
+        reload: (callback: (error?: Error | null) => void) => callback(null),
+      }),
+    ).resolves.toBe(true);
+  });
+
+  it('reports an absent record instead of failing the refresh', async () => {
+    await expect(
+      reloadOpenIDSessionIfPersisted({
+        reload: (callback: (error?: Error | null) => void) =>
+          callback(new Error('failed to load session')),
+      }),
+    ).resolves.toBe(false);
+  });
+
+  it('propagates a session store outage', async () => {
+    const error = new Error('connection unavailable');
+    await expect(
+      reloadOpenIDSessionIfPersisted({
+        reload: (callback: (error?: Error | null) => void) => callback(error),
+      }),
+    ).rejects.toBe(error);
+  });
+
+  it('reports a request without a reloadable session', async () => {
+    await expect(reloadOpenIDSessionIfPersisted(undefined)).resolves.toBe(false);
+  });
+});
diff --git a/packages/api/src/auth/openid/errors.ts b/packages/api/src/auth/openid/errors.ts
index f4844e9fc2d..7de34b29b19 100644
--- a/packages/api/src/auth/openid/errors.ts
+++ b/packages/api/src/auth/openid/errors.ts
@@ -8,6 +8,39 @@ export function isOpenIDSessionMissingError(error: unknown): boolean {
   return error instanceof Error && error.message === 'failed to load session';
 }
 
+/**
+ * Reloads the persisted Express session before a publication decision. express-session rejects with
+ * `failed to load session` when the record is merely absent — the session-store TTL elapsed, the
+ * entry was evicted, or a logout in another replica removed it — which describes an empty session
+ * rather than one that advanced past this result. Tolerate that case so a refresh backed by a
+ * still-valid refresh token seeds a new record instead of demanding an interactive sign-in, and let
+ * every other store failure (an outage) propagate to the caller.
+ *
+ * Logout safety does not depend on this record: `revokeOpenIDRefreshTokenChain` writes a durable
+ * revoked publication flight for every refresh token it retires, so a retired token still fails.
+ *
+ * @returns `true` when the persisted record was read, `false` when it was gone.
+ */
+export async function reloadOpenIDSessionIfPersisted(
+  session?: { reload?: (callback: (error?: Error | null) => void) => void } | null,
+): Promise<boolean> {
+  if (typeof session?.reload !== 'function') {
+    return false;
+  }
+  const reload = session.reload.bind(session);
+  try {
+    await new Promise<void>((resolve, reject) => {
+      reload((error?: Error | null) => (error ? reject(error) : resolve()));
+    });
+    return true;
+  } catch (error) {
+    if (isOpenIDSessionMissingError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+
 export function toOpenIDLogArgument(error: unknown): LogArgument {
   return error instanceof Error ? error : String(error);
 }
diff --git a/packages/api/src/auth/openid/recovery.spec.ts b/packages/api/src/auth/openid/recovery.spec.ts
index ba512edb0b4..124e3da7e8a 100644
--- a/packages/api/src/auth/openid/recovery.spec.ts
+++ b/packages/api/src/auth/openid/recovery.spec.ts
@@ -51,17 +51,52 @@ describe('OpenID authentication publication settlement', () => {
     return { deps, service, input };
   }
 
-  it('settles a missing-session failure immediately and preserves the original error', async () => {
+  /** A session whose persisted record is gone: the store TTL elapsed, or an eviction removed it. */
+  function missingSessionRequest() {
+    return {
+      session: {
+        reload: (callback: (error: Error) => void) => callback(new Error('failed to load session')),
+        save: (callback: (error?: Error | null) => void) => callback(null),
+      },
+    };
+  }
+
+  it('publishes into a new session when the persisted record expired', async () => {
     const { deps, service, input } = setup();
-    const error = new Error('failed to load session');
-    const req = { session: { reload: (callback: (error: Error) => void) => callback(error) } };
-    await expect(service.sendOpenIDAuthResponse({ ...input, req })).rejects.toBe(error);
-    expect(deps.failOpenIDRefreshFlight).toHaveBeenCalledWith({
-      key: 'publication',
-      ownerId: 'owner',
-      error,
-    });
+    await expect(
+      service.sendOpenIDAuthResponse({ ...input, req: missingSessionRequest() }),
+    ).resolves.toBe('app-token');
+    expect(deps.completeOpenIDRefreshFlight).toHaveBeenCalledTimes(1);
+    expect(deps.failOpenIDRefreshFlight).not.toHaveBeenCalled();
+  });
+
+  /**
+   * Tolerating an absent record leaves the durable revoked publication flight as the only fence
+   * against resurrecting a logged-out session, so both of its checks are pinned here: the
+   * tombstone read that precedes the reload, and the completion that follows it.
+   */
+  it('refuses a revoked generation before reloading the expired session', async () => {
+    const { deps, service, input } = setup();
+    deps.acquireOpenIDRefreshFlight.mockResolvedValue({ acquired: false, ownerId: 'other' });
+    deps.waitForOpenIDRefreshFlight.mockRejectedValue(
+      new Error('OpenID refresh was revoked by logout'),
+    );
+    await expect(
+      service.sendOpenIDAuthResponse({ ...input, req: missingSessionRequest() }),
+    ).rejects.toThrow('revoked by logout');
     expect(deps.completeOpenIDRefreshFlight).not.toHaveBeenCalled();
+    expect(deps.setOpenIDAuthTokens).not.toHaveBeenCalled();
+  });
+
+  it('withholds tokens when logout revokes the flight after the expired session reloaded', async () => {
+    const { deps, service, input } = setup();
+    deps.completeOpenIDRefreshFlight.mockResolvedValue(null);
+    await expect(
+      service.sendOpenIDAuthResponse({ ...input, req: missingSessionRequest() }),
+    ).rejects.toThrow('revoked before completion');
+    expect(deps.setOpenIDAuthTokens).not.toHaveBeenCalled();
+    expect(deps.deleteOpenIDSession).toHaveBeenCalledWith('refresh');
+    expect(deps.clearOpenIDAuthTokens).toHaveBeenCalled();
   });
 
   it('preserves the request error when failure settlement also fails', async () => {
diff --git a/packages/api/src/auth/openid/recovery.ts b/packages/api/src/auth/openid/recovery.ts
index baa61a57383..1413bcf93d2 100644
--- a/packages/api/src/auth/openid/recovery.ts
+++ b/packages/api/src/auth/openid/recovery.ts
@@ -22,6 +22,7 @@ import type { TokenResult } from './flight';
 import {
   createOpenIDRefreshOwnershipError,
   isOpenIDRefreshOwnershipError,
+  reloadOpenIDSessionIfPersisted,
   toOpenIDLogArgument,
 } from './errors';
 
@@ -800,12 +801,7 @@ export function createOpenIDRefreshRecoveryService(
     if (assertLeaseOwned) {
       await assertLeaseOwned();
     }
-    if (typeof req?.session?.reload === 'function') {
-      const reload = req.session.reload.bind(req.session);
-      await new Promise<void>((resolve, reject) => {
-        reload((error?: Error | null) => (error ? reject(error) : resolve()));
-      });
-    }
+    await reloadOpenIDSessionIfPersisted(req?.session);
     if (discardSessionTokens && req?.session?.openidTokens) {
       delete req.session.openidTokens;
     }
diff --git a/packages/api/src/auth/openid/session.ts b/packages/api/src/auth/openid/session.ts
index 6782bbb45b8..28cbb8c3833 100644
--- a/packages/api/src/auth/openid/session.ts
+++ b/packages/api/src/auth/openid/session.ts
@@ -28,6 +28,7 @@ import {
   OPENID_REFRESH_CANCELLED_BEFORE_GRANT,
   createOpenIDRefreshOwnershipError,
   isOpenIDRefreshOwnershipError,
+  reloadOpenIDSessionIfPersisted,
   toOpenIDLogArgument,
 } from './errors';
 
@@ -1239,12 +1240,7 @@ export function createOpenIDSessionRefreshService(
   }): Promise<MarkedOIDCTokens | null> {
     if (!resolvedTokens?.access_token) return null;
     if (assertLeaseOwned) await assertLeaseOwned();
-    if (typeof req.session?.reload === 'function') {
-      const reload = req.session.reload.bind(req.session);
-      await new Promise<void>((resolve, reject) => {
-        reload((error?: Error | null) => (error ? reject(error) : resolve()));
-      });
-    }
+    await reloadOpenIDSessionIfPersisted(req.session);
     if (assertLeaseOwned) await assertLeaseOwned();
     const requestTokens = cloneResolvedTokens(resolvedTokens);
     if (
@@ -1778,11 +1774,8 @@ export function createOpenIDSessionRefreshService(
     if (!req?.session || !resolvedTokens?.access_token) {
       return false;
     }
-    if (reloadSession && typeof req.session.reload === 'function') {
-      const reload = req.session.reload.bind(req.session);
-      await new Promise<void>((resolve, reject) => {
-        reload((error?: Error | null) => (error ? reject(error) : resolve()));
-      });
+    if (reloadSession) {
+      await reloadOpenIDSessionIfPersisted(req.session);
     }
     const existing = req.session.openidTokens ?? {};
     const generationDiffers = Boolean(
diff --git a/packages/client/src/components/Composer.tsx b/packages/client/src/components/Composer.tsx
index da1427ced69..46a303ddc77 100644
--- a/packages/client/src/components/Composer.tsx
+++ b/packages/client/src/components/Composer.tsx
@@ -7,7 +7,11 @@ import type {
   RefAttributes,
 } from 'react';
 import type { SendAction } from './SendActions';
-import { composerSurfaceClasses, composerSurfaceShadow } from '~/utils/composer';
+import {
+  composerSubmitClasses,
+  composerSurfaceClasses,
+  composerSurfaceShadow,
+} from '~/utils/composer';
 import { TextareaAutosize } from './TextareaAutosize';
 import { SendActions } from './SendActions';
 import { TooltipAnchor } from './Tooltip';
@@ -82,8 +86,7 @@ export type ComposerStopProps =
 export type ComposerPropsWithStop = ComposerProps & ComposerStopProps;
 
 /** Main chat's send/stop button shape, shared by both states of the slot. */
-const CONTROL_CLASS =
-  'size-theme-control rounded-theme-control-round bg-text-primary p-theme-compact text-text-primary outline-offset-4 transition-all duration-theme-normal disabled:cursor-not-allowed disabled:text-text-secondary disabled:opacity-10';
+const CONTROL_CLASS = composerSubmitClasses();
 
 /**
  * The chat composer at panel scale: one persistent surface with a text field, a
diff --git a/packages/client/src/theme/tailwind.spec.js b/packages/client/src/theme/tailwind.spec.js
index 695972ad0e8..741d381e10e 100644
--- a/packages/client/src/theme/tailwind.spec.js
+++ b/packages/client/src/theme/tailwind.spec.js
@@ -27,6 +27,9 @@ describe('LibreChat Tailwind preset', () => {
     expect(resolved.theme.spacing['theme-control']).toBe(
       `var(--theme-control-height, ${defaultAppearance.controlHeight})`,
     );
+    expect(resolved.theme.spacing['theme-control-touch']).toBe(
+      `max(var(--theme-control-height, ${defaultAppearance.controlHeight}), 2.75rem)`,
+    );
     expect(resolved.theme.borderRadius['theme-control']).toBe(
       `var(--theme-control-radius, ${defaultAppearance.controlRadius})`,
     );
@@ -50,6 +53,24 @@ describe('LibreChat Tailwind preset', () => {
     );
   });
 
+  /** The tap-target floor is half CSS and half variant: a spacing key nothing can
+   *  reach is not a floor, so the registration is asserted, not just the value. */
+  it('registers the appearance variants the utilities are written against', () => {
+    const variants = {};
+    tailwindPreset.plugins.forEach((plugin) =>
+      plugin({
+        addVariant: (name, value) => {
+          variants[name] = value;
+        },
+      }),
+    );
+
+    /** `any-pointer`, not `pointer`: the floor has to apply to a 2-in-1's
+     *  touchscreen while its trackpad is the primary device and reports `fine`. */
+    expect(variants.touch).toBe('@media (any-pointer: coarse)');
+    expect(variants['high-contrast']).toBe('html.high-contrast &');
+  });
+
   it('exposes the preset in the published package', () => {
     expect(packageJson.files).toContain('tailwind.preset.cjs');
     expect(packageJson.exports['./tailwind-preset']).toBe('./tailwind.preset.cjs');
diff --git a/packages/client/src/utils/composer.spec.ts b/packages/client/src/utils/composer.spec.ts
index f69ed6b29de..5bbe8285129 100644
--- a/packages/client/src/utils/composer.spec.ts
+++ b/packages/client/src/utils/composer.spec.ts
@@ -1,4 +1,4 @@
-import { composerControlClasses, composerSurfaceClasses } from './composer';
+import { composerControlClasses, composerSubmitClasses, composerSurfaceClasses } from './composer';
 
 describe('composerSurfaceClasses', () => {
   it('draws the composer surface from semantic roles', () => {
@@ -10,6 +10,32 @@ describe('composerSurfaceClasses', () => {
   });
 });
 
+describe('composerSubmitClasses', () => {
+  it('owns the send/stop geometry from the shared tokens', () => {
+    const classes = composerSubmitClasses();
+
+    expect(classes).toContain('size-theme-control');
+    expect(classes).toContain('rounded-theme-control-round');
+    expect(classes).toContain('p-theme-compact');
+  });
+
+  it('floors the tap target wherever touch is reachable, and centers the icon', () => {
+    const classes = composerSubmitClasses();
+
+    expect(classes).toContain('touch:size-theme-control-touch');
+    expect(classes).toContain('items-center');
+    expect(classes).toContain('justify-center');
+  });
+
+  it('draws its fill and disabled state from semantic roles', () => {
+    const classes = composerSubmitClasses();
+
+    expect(classes).toContain('bg-text-primary');
+    expect(classes).toContain('disabled:text-text-secondary');
+    expect(classes).not.toMatch(/#[0-9a-f]{3,6}|rgb\(|hsl\(/i);
+  });
+});
+
 describe('composerControlClasses', () => {
   it('owns the geometry every labeled composer control shares', () => {
     const classes = composerControlClasses();
diff --git a/packages/client/src/utils/composer.ts b/packages/client/src/utils/composer.ts
index 9c2527758d1..73f1d5ee091 100644
--- a/packages/client/src/utils/composer.ts
+++ b/packages/client/src/utils/composer.ts
@@ -18,6 +18,28 @@ export const composerSurfaceShadow = {
   within: 'shadow-md focus-within:shadow-lg',
 } as const;
 
+/**
+ * The composer's submit slot: send, stop, and the during-run send button that
+ * takes their place while a run generates. One recipe because all three swap
+ * into the same position and must be indistinguishable in everything but the
+ * icon they carry.
+ *
+ * Wherever touch is reachable it is the row's one 44px target. `size-theme-control` is
+ * 36px, which a thumb aimed at the bottom corner of a phone clips or misses
+ * outright, and below `sm` the composer surface runs to the viewport floor by
+ * design, so the target has to grow upward instead of gaining a band of padding
+ * beneath it. Centering is `flex` rather than the icon's fit inside
+ * `p-theme-compact`, which only held while the box was exactly icon-sized.
+ */
+export const composerSubmitClasses = (): string =>
+  cn(
+    'flex items-center justify-center',
+    'size-theme-control touch:size-theme-control-touch',
+    'rounded-theme-control-round bg-text-primary p-theme-compact text-text-primary',
+    'outline-offset-4 transition-all duration-theme-normal',
+    'disabled:cursor-not-allowed disabled:text-text-secondary disabled:opacity-10',
+  );
+
 /**
  * Shared appearance for a labeled control in the composer's action row — the
  * capability checkboxes, the MCP selector, the code-approval selector. Border,
diff --git a/packages/client/tailwind.preset.cjs b/packages/client/tailwind.preset.cjs
index 53c11d51754..71182d83352 100644
--- a/packages/client/tailwind.preset.cjs
+++ b/packages/client/tailwind.preset.cjs
@@ -12,6 +12,12 @@ module.exports = {
         'theme-compact': 'var(--theme-space-compact, 0.375rem)',
         'theme-normal': 'var(--theme-space-normal, 0.75rem)',
         'theme-control': 'var(--theme-control-height, 2.25rem)',
+        /**
+         * The comfortable tap target (2.75rem / 44px), held against the theme's
+         * own control height with `max()` so a theme that already draws larger
+         * controls is never shrunk on a phone. Pair it with `touch:`.
+         */
+        'theme-control-touch': 'max(var(--theme-control-height, 2.25rem), 2.75rem)',
       },
       borderRadius: {
         'theme-control': 'var(--theme-control-radius, 0.75rem)',
@@ -48,6 +54,22 @@ module.exports = {
        * `high-contrast-dark` choice as well as the OS preference.
        */
       addVariant('high-contrast', 'html.high-contrast &');
+
+      /**
+       * Touch is reachable at all — `any-pointer`, deliberately not `pointer`.
+       * `pointer` describes only the PRIMARY pointing device, so a 2-in-1 driven
+       * by its trackpad reports `fine` with its touchscreen right there, and a
+       * tap-target floor written against `(pointer: coarse)` would never reach
+       * the finger it exists for.
+       *
+       * Not the query `useFocusChatEffect` and the composer's focus guard branch
+       * on, though it looks like it: those ask "would focusing raise an on-screen
+       * keyboard over the thread", which is a question about the primary input and
+       * must keep answering `fine` for the trackpad user on that same 2-in-1. A
+       * tap target asks the other question — whether a finger can reach the
+       * control at all — so the two queries differ on purpose.
+       */
+      addVariant('touch', '@media (any-pointer: coarse)');
     },
   ],
 };