diff --git a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
index a5c747364f4..59e24d3c8df 100644
--- a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
+++ b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
@@ -738,6 +738,7 @@ describe('ResumableAgentController resume metadata', () => {
           model: 'gpt-3.5-turbo',
           /** The OWNING replica's seal capability, read by the steer route. */
           preemptCapable: true,
+          steerQuotesCapable: true,
           agent_id: undefined,
           isTemporary: true,
           responseMessageId: expect.stringMatching(/^[0-9a-f-]{36}$/),
diff --git a/api/server/controllers/agents/client.js b/api/server/controllers/agents/client.js
index 320abe0691d..6c1b6a61368 100644
--- a/api/server/controllers/agents/client.js
+++ b/api/server/controllers/agents/client.js
@@ -58,6 +58,7 @@ const {
   isSteeringSupported,
   isSteerPreemptSupported,
   buildSteerMedia,
+  collectSteerStampTargets,
   stampSteerPartMedia,
   createActivityLabelWiring,
   createActivityPhaseWiring,
@@ -387,6 +388,9 @@ class AgentClient extends BaseClient {
       ...(item.clientSteerId && { clientSteerId: item.clientSteerId }),
       createdAt: item.createdAt,
       ...(item.files?.length && { files: item.files }),
+      // Persisted separately from the text (mirroring `message.quotes`) so the
+      // UI renders reference blocks and replay re-merges them per turn.
+      ...(item.quotes?.length && { quotes: item.quotes }),
     };
     this.contentParts.push(part);
     this.steerOffsetState.offset += 1;
@@ -1892,22 +1896,33 @@ class AgentClient extends BaseClient {
 
     payload = formattedMessages;
     this.modelBoundSteerFileIdsBySourceMessageId = new Map();
-    if (this.options.resendFiles) {
-      /** Persisted steer parts of past turns replay with their attachments:
-       *  one batched owner-scoped fetch, re-encoded per turn and stamped as a
-       *  transient `media` array (same resend semantics as message files).
-       *  The stamp lands after the loop above finalized its counts, so the
-       *  re-encoded media (minus the text part the steer part already counted)
-       *  is folded into the budget here — large steered attachments must
-       *  shrink the window like any other resent media. */
+    /** Persisted steer parts of past turns replay with their attachments and
+     *  quotes: one batched owner-scoped fetch, re-encoded per turn and
+     *  stamped as a transient `media` array (same resend semantics as
+     *  message files). Runs regardless of `resendFiles` because quote-bearing
+     *  parts must re-merge their excerpts every turn (mirroring
+     *  `prependQuotes` above); file encoding stays gated on the setting via
+     *  the flag. The stamp lands after the loop above finalized its counts,
+     *  so the re-encoded media (minus the text part the steer part already
+     *  counted) is folded into the budget here — large steered attachments
+     *  and quote blocks must shrink the window like any other resent media.
+     *  The synchronous collection keeps steer-free histories on the
+     *  zero-await path to the parallel context kickoff below, and the
+     *  collected targets feed the stamp directly so the history is scanned
+     *  once. */
+    const resendSteerFiles = this.options.resendFiles === true;
+    const steerStampTargets = collectSteerStampTargets(payload, resendSteerFiles);
+    if (steerStampTargets.length > 0) {
       const stamped = await stampSteerPartMedia({
         client: this,
         user: this.options.req?.user,
         payload,
+        targets: steerStampTargets,
         // addPreviousAttachments already fetched steer-part refs in its single
         // per-turn historical-files query — no second round trip.
         docsById: this.authorizedHistoricalFiles,
         getFiles: db.getFiles,
+        resendFiles: resendSteerFiles,
       });
       for (const { sourceMessageId, fileIds } of stamped) {
         if (typeof sourceMessageId !== 'string' || sourceMessageId.length === 0) {
@@ -1927,8 +1942,8 @@ class AgentClient extends BaseClient {
       for (const { index, media, steerText } of stamped) {
         /** Count the FULL stamped content and subtract only the steer body
          *  (already counted inside the assistant message): extracted file
-         *  context prepended into the text part must hit the budget too, or
-         *  large steered documents bypass pruning. */
+         *  context and merged quote blocks prepended into the text part must
+         *  hit the budget too, or large steered documents bypass pruning. */
         const fullTokens = countFormattedMessageTokens({ role: 'user', content: media }, encoding);
         const bodyTokens = steerText
           ? countFormattedMessageTokens(
@@ -1949,6 +1964,25 @@ class AgentClient extends BaseClient {
           memoryFormattedMessages[i] ?? buildMemoryFormattedMessage(orderedMessages[i]),
         );
       }
+      /** The memory copy feeds `processMemory` through the same
+       *  `formatAgentMessages` replay, which reads `part.media`/`part.steer`
+       *  and ignores `part.quotes` — so a steer whose substance lives in its
+       *  quote must be quote-merged here too or memory extraction never sees
+       *  it. Quote merge only (`resendFiles: false`): file media is exactly
+       *  what the memory copy exists to exclude, and text-only stamps touch
+       *  no file fetch or encode. Runs after the fill above so late-built
+       *  copies are stamped too. */
+      const memorySteerTargets = collectSteerStampTargets(memoryPayload, false);
+      if (memorySteerTargets.length > 0) {
+        await stampSteerPartMedia({
+          client: this,
+          user: this.options.req?.user,
+          payload: memoryPayload,
+          targets: memorySteerTargets,
+          getFiles: db.getFiles,
+          resendFiles: false,
+        });
+      }
     }
     this.memoryPayload = hasFileContext ? memoryPayload : null;
     messages = orderedMessages;
diff --git a/api/server/controllers/agents/client.test.js b/api/server/controllers/agents/client.test.js
index 073daddbf0c..9b8d3200e99 100644
--- a/api/server/controllers/agents/client.test.js
+++ b/api/server/controllers/agents/client.test.js
@@ -3749,6 +3749,60 @@ describe('AgentClient - titleConvo', () => {
       );
     });
 
+    it('quote-merges historical steer parts into the prompt AND the memory copy', async () => {
+      const previousFileContext =
+        'Attached document(s):\n```md\n# "previous.txt"\nPrevious turn file body\n```';
+
+      const result = await client.buildMessages(
+        [
+          {
+            messageId: 'msg-1',
+            parentMessageId: null,
+            sender: 'User',
+            text: 'Summarize.',
+            isCreatedByUser: true,
+            fileContext: previousFileContext,
+          },
+          {
+            messageId: 'msg-2',
+            parentMessageId: 'msg-1',
+            sender: 'Assistant',
+            text: '',
+            isCreatedByUser: false,
+            content: [
+              { type: ContentTypes.TEXT, text: 'working on it' },
+              {
+                type: ContentTypes.STEER,
+                [ContentTypes.STEER]: 'remember this',
+                steerId: 's1',
+                quotes: ['the important fact'],
+              },
+            ],
+          },
+          {
+            messageId: 'msg-3',
+            parentMessageId: 'msg-2',
+            sender: 'User',
+            text: 'Continue.',
+            isCreatedByUser: true,
+          },
+        ],
+        'msg-3',
+        {},
+      );
+
+      const merged = '> the important fact\n\nremember this';
+      const promptSteer = result.prompt[1].content.find((part) => part.type === ContentTypes.STEER);
+      expect(promptSteer.media).toEqual([{ type: ContentTypes.TEXT, text: merged }]);
+      // The memory copy replays through the same formatter, which ignores
+      // `part.quotes` — it needs its own merged stamp or memory extraction
+      // never sees the excerpt.
+      const memorySteer = client.memoryPayload[1].content.find(
+        (part) => part.type === ContentTypes.STEER,
+      );
+      expect(memorySteer.media).toEqual([{ type: ContentTypes.TEXT, text: merged }]);
+    });
+
     it('persists canonical token counts while counting request file context for the prompt', async () => {
       const { countFormattedMessageTokens } = require('@librechat/api');
       const currentFile = makeTextFile('current-file', 'current.txt', 'Current turn file body');
diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.js
index 0ab98fdb0ce..75a1ee744c6 100644
--- a/api/server/controllers/agents/request.js
+++ b/api/server/controllers/agents/request.js
@@ -444,7 +444,7 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
   const isRecoveredSteerRequest = recoveredSteerId != null;
   const recoveryUserMessageId = rawOverrideUserMessageId;
   const recoveredSteerPayload = isRecoveredSteerRequest
-    ? buildRecoveredSteerPayload(text, req.body?.files)
+    ? buildRecoveredSteerPayload(text, req.body?.files, req.body?.quotes)
     : undefined;
   /** A recovered steer is handed off as a new ordinary user turn. Edit,
    * regenerate, continue, and arbitrary override-id shapes can reuse an
@@ -1106,6 +1106,10 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
         // route may land on a different replica whose own SDK probe would
         // answer for the wrong process during a rolling deploy.
         preemptCapable: isSteerPreemptSupported(),
+        // Same owner-recorded pattern: this build's drain merges queued steer
+        // quotes into the injected turn. Admission on another replica must
+        // not store/acknowledge quotes an older owner would drop.
+        steerQuotesCapable: true,
         // Persist the originating agent so a HITL resume can refuse to rebuild this
         // paused run on a different agent (see resume.js).
         agent_id: endpointOption.agent_id ?? req.body?.agent_id,
diff --git a/api/server/controllers/agents/resume.js b/api/server/controllers/agents/resume.js
index 30e3c8c73c8..5d54b6c96f5 100644
--- a/api/server/controllers/agents/resume.js
+++ b/api/server/controllers/agents/resume.js
@@ -1222,6 +1222,9 @@ const ResumeAgentController = async (req, res, next, initializeClient, addTitle)
         pendingAction.actionId,
         {
           preemptCapable: isSteerPreemptSupported(),
+          // The handover owner's quote handling replaces the previous
+          // replica's flag, mirroring `preemptCapable` above.
+          steerQuotesCapable: true,
           providerExecutionId,
           providerDrained: true,
           ...(resolvedAskUserQuestion && { resolvedAskUserQuestions }),
diff --git a/client/jest.config.cjs b/client/jest.config.cjs
index 996a9fb7e6c..94dc2bfa65e 100644
--- a/client/jest.config.cjs
+++ b/client/jest.config.cjs
@@ -25,6 +25,8 @@ module.exports = {
   // },
   moduleNameMapper: {
     '\\.(css)$': 'identity-obj-proxy',
+    /** Mirror the vite resolve.alias so tests parse math with the same tokenizer as production. */
+    '^micromark-extension-math$': 'micromark-extension-llm-math',
     '\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$':
       'jest-file-loader',
     '^test/(.*)$': '<rootDir>/test/$1',
diff --git a/client/package.json b/client/package.json
index 48de22cdda6..1bbea2c537d 100644
--- a/client/package.json
+++ b/client/package.json
@@ -91,6 +91,8 @@
     "micromark-extension-gfm": "^3.0.0",
     "micromark-extension-llm-math": "^3.1.0",
     "micromark-extension-math": "^3.1.0",
+    "micromark-util-character": "^2.1.0",
+    "micromark-util-symbol": "^2.0.0",
     "monaco-editor": "^0.56.0",
     "qrcode.react": "^4.2.0",
     "rc-input-number": "^7.4.2",
@@ -159,6 +161,7 @@
     "jest-environment-jsdom": "^30.2.0",
     "jest-file-loader": "^1.0.3",
     "jest-junit": "^17.0.0",
+    "micromark-util-types": "^2.0.0",
     "postcss": "^8.5.18",
     "postcss-preset-env": "^11.2.0",
     "tailwindcss": "^3.4.1",
diff --git a/client/src/components/Chat/Input/InFlightSteers.tsx b/client/src/components/Chat/Input/InFlightSteers.tsx
index 633e6250a9a..e959b64693f 100644
--- a/client/src/components/Chat/Input/InFlightSteers.tsx
+++ b/client/src/components/Chat/Input/InFlightSteers.tsx
@@ -16,6 +16,7 @@ import {
 import FilePreviewDialog from '~/components/Chat/Messages/Content/FilePreviewDialog';
 import { supportsGenerationProtocolV2, useArmSteerMutation } from '~/data-provider';
 import { steerOverlayHeightFamily, escalatingSteerFamily } from '~/store/steer';
+import MessageQuotes from '~/components/Chat/Messages/Content/MessageQuotes';
 import MarkdownLite from '~/components/Chat/Messages/Content/MarkdownLite';
 import FileContainer from '~/components/Chat/Input/Files/FileContainer';
 import { useSteerCancel, useSteerReclaim, useLocalize } from '~/hooks';
@@ -482,6 +483,9 @@ const InFlightSteer = memo(function InFlightSteer({
             {localize(preempting ? 'com_ui_steer_in_flight_preempt' : 'com_ui_steer_in_flight')}
           </span>
           <div className="flex min-w-0 flex-col items-start gap-1">
+            {/* Same reference blocks the applied `SteerPart` shows, outside the
+             *  collapse so the excerpts stay visible while a long steer clips. */}
+            <MessageQuotes quotes={steer.quotes} />
             <div
               ref={contentRef}
               id={contentId}
diff --git a/client/src/components/Chat/Input/PendingQuoteChips.tsx b/client/src/components/Chat/Input/PendingQuoteChips.tsx
index 7ba436c0621..1ea04ff67a0 100644
--- a/client/src/components/Chat/Input/PendingQuoteChips.tsx
+++ b/client/src/components/Chat/Input/PendingQuoteChips.tsx
@@ -26,9 +26,11 @@ const CLOSE_DELAY_MS = 120;
  * `autoFocusOnShow` is disabled so opening never pulls focus off the composer;
  * `autoFocusOnHide` still returns focus to the trigger when focus was inside.
  *
- * Reads + writes `pendingQuotesByConvoId` directly; the atom is drained in
- * `useChatFunctions.ask` on submit, so chips disappear once the message is sent
- * (the excerpts then re-render as `MessageQuotes` on the user bubble).
+ * Reads + writes `pendingQuotesByConvoId` directly; the atom is drained on
+ * every submit route — `useChatFunctions.ask` for a fresh send, and the
+ * during-run steer/queue/interrupt paths in `useSteering` — so chips disappear
+ * once the message is sent (the excerpts then re-render as `MessageQuotes` on
+ * the user bubble, or inside the steer bubble for a mid-run injection).
  */
 function PendingQuoteChips({ conversationId }: { conversationId: string }) {
   const localize = useLocalize();
diff --git a/client/src/components/Chat/Input/PendingSteerChips.tsx b/client/src/components/Chat/Input/PendingSteerChips.tsx
index a6f9bff00b8..9de0802c88d 100644
--- a/client/src/components/Chat/Input/PendingSteerChips.tsx
+++ b/client/src/components/Chat/Input/PendingSteerChips.tsx
@@ -2,7 +2,7 @@ import { memo, useMemo, useRef, useState, useCallback } from 'react';
 import { useAtomValue } from 'jotai';
 import { useRecoilValue } from 'recoil';
 import { useToastContext } from '@librechat/client';
-import { X, Zap, Send, Clock, Pencil, Trash2, Paperclip, RotateCcw } from 'lucide-react';
+import { X, Zap, Send, Clock, Pencil, Trash2, Paperclip, RotateCcw, TextQuote } from 'lucide-react';
 import type { TMessage } from 'librechat-data-provider';
 import type { SteeringControls, QueuedMessageContext } from '~/hooks/Chat/useSteering';
 import type { PendingSteer, QueuedMessage } from '~/store/families';
@@ -24,19 +24,47 @@ import store from '~/store';
 const ROW_CLASS =
   'flex w-full items-center gap-2 rounded-xl border border-border-light bg-surface-secondary px-3 py-2 text-sm text-text-primary';
 
-function AttachmentCount({ count, label }: { count: number; label: string }) {
+function ContextCount({
+  icon,
+  count,
+  label,
+}: {
+  icon: React.ReactNode;
+  count: number;
+  label: string;
+}) {
   if (count === 0) {
     return null;
   }
   return (
     <span className="flex shrink-0 items-center gap-0.5 text-xs text-text-secondary">
-      <Paperclip className="h-3.5 w-3.5" aria-hidden="true" />
+      {icon}
       {count}
       <span className="sr-only">{label}</span>
     </span>
   );
 }
 
+function AttachmentCount({ count, label }: { count: number; label: string }) {
+  return (
+    <ContextCount
+      icon={<Paperclip className="h-3.5 w-3.5" aria-hidden="true" />}
+      count={count}
+      label={label}
+    />
+  );
+}
+
+function QuoteCount({ count, label }: { count: number; label: string }) {
+  return (
+    <ContextCount
+      icon={<TextQuote className="h-3.5 w-3.5" aria-hidden="true" />}
+      count={count}
+      label={label}
+    />
+  );
+}
+
 function QueuedRow({
   message,
   steering,
@@ -61,6 +89,7 @@ function QueuedRow({
   const toggleEntry = useDefaultToggleEntry(steering);
   const interruptToggle = useInterruptToggleEntry();
   const fileCount = message.files?.length ?? 0;
+  const quoteCount = message.quotes?.length ?? 0;
   const isRecovered = message.recoverySteerId != null;
   const actionPendingRef = useRef(false);
   const [actionPending, setActionPending] = useState(false);
@@ -147,6 +176,10 @@ function QueuedRow({
       <span className="min-w-0 flex-1 truncate" title={message.text}>
         {message.text}
       </span>
+      <QuoteCount
+        count={quoteCount}
+        label={localize('com_ui_queued_quote_count', { 0: String(quoteCount) })}
+      />
       <AttachmentCount
         count={fileCount}
         label={localize('com_ui_queued_attachment_count', { 0: String(fileCount) })}
@@ -275,6 +308,10 @@ function FailedSteerRow({
       <span className="min-w-0 flex-1 truncate" title={steer.text}>
         {steer.text}
       </span>
+      <QuoteCount
+        count={steer.quotes?.length ?? 0}
+        label={localize('com_ui_queued_quote_count', { 0: String(steer.quotes?.length ?? 0) })}
+      />
       <span className="shrink-0 text-xs text-red-500">
         {localize(
           steer.deliveryUncertain ? 'com_ui_steer_delivery_unconfirmed' : 'com_ui_steer_failed',
diff --git a/client/src/components/Chat/Input/QuoteButton.tsx b/client/src/components/Chat/Input/QuoteButton.tsx
index 1d72ea28c5b..712f84df827 100644
--- a/client/src/components/Chat/Input/QuoteButton.tsx
+++ b/client/src/components/Chat/Input/QuoteButton.tsx
@@ -2,18 +2,15 @@ import { memo, useRef, useState, useEffect, useCallback, useLayoutEffect } from
 import { createPortal } from 'react-dom';
 import { TextQuote } from 'lucide-react';
 import { useSetRecoilState } from 'recoil';
+import { cn, MAX_QUOTE_COUNT } from '~/utils';
 import { mainTextareaId } from '~/common';
 import { useLocalize } from '~/hooks';
-import { cn } from '~/utils';
 import store from '~/store';
 
 /** Only selections fully inside a rendered chat message get the popup. */
 const MESSAGE_SELECTOR = '.message-render';
 /** Max characters captured per excerpt (backend re-caps as defense-in-depth). */
 const MAX_QUOTE_LENGTH = 1500;
-/** Max excerpts queued at once; mirrors the backend `QUOTE_MAX_COUNT` cap so
- *  the composer never shows more quotes than the model actually receives. */
-const MAX_QUOTE_COUNT = 10;
 /** Vertical gap (px) between the selection and the popup. */
 const POPUP_OFFSET = 8;
 /** Keep the popup this far (px) from the viewport edges. */
diff --git a/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx b/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx
index 9be37aefe9f..97d228f48d5 100644
--- a/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx
+++ b/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx
@@ -185,6 +185,19 @@ describe('InFlightSteers', () => {
     expect(screen.queryByTestId('in-flight-steers')).toBeNull();
   });
 
+  it('renders carried quotes as the same reference blocks the applied part shows', () => {
+    renderSteers([
+      {
+        steerId: 's-quoted',
+        text: 'about the selection',
+        status: 'pending',
+        createdAt: 1,
+        quotes: ['the selected excerpt'],
+      },
+    ]);
+    expect(screen.getByTestId('message-quotes')).toHaveTextContent('the selected excerpt');
+  });
+
   it('shows the menu at rest on every pointer, without hover-gating', () => {
     renderSteers([
       { steerId: 's-ack', text: 'waiting on boundary', status: 'pending', createdAt: 1 },
diff --git a/client/src/components/Chat/Messages/Content/Markdown.tsx b/client/src/components/Chat/Messages/Content/Markdown.tsx
index 8727638dda2..24b3cc26249 100644
--- a/client/src/components/Chat/Messages/Content/Markdown.tsx
+++ b/client/src/components/Chat/Messages/Content/Markdown.tsx
@@ -1,4 +1,4 @@
-import React, { memo, useMemo, useRef, useEffect } from 'react';
+import React, { memo, useRef, useEffect } from 'react';
 import { useRecoilValue } from 'recoil';
 import { getRemarkPlugins, getRehypePlugins, getMarkdownComponents } from './markdownConfig';
 import useSmoothStreaming from '~/hooks/Messages/useSmoothStreaming';
@@ -6,7 +6,6 @@ import MarkdownErrorBoundary from './MarkdownErrorBoundary';
 import { FADE_HYDRATION_THRESHOLD } from './animate';
 import { useMessageContext } from '~/Providers';
 import MarkdownBlocks from './MarkdownBlocks';
-import { preprocessLaTeX } from '~/utils';
 import store from '~/store';
 
 type TContentProps = {
@@ -39,13 +38,6 @@ const Markdown = memo(function Markdown({ content = '', isLatestMessage }: TCont
     }
   }, [animate]);
 
-  const currentContent = useMemo(() => {
-    if (isInitializing) {
-      return '';
-    }
-    return LaTeXParsing ? preprocessLaTeX(content) : content;
-  }, [content, LaTeXParsing, isInitializing]);
-
   if (isInitializing) {
     return (
       <div className="absolute">
@@ -59,8 +51,8 @@ const Markdown = memo(function Markdown({ content = '', isLatestMessage }: TCont
   return (
     <MarkdownErrorBoundary content={content} codeExecution={true}>
       <MarkdownBlocks
-        content={currentContent}
-        remarkPlugins={getRemarkPlugins()}
+        content={content}
+        remarkPlugins={getRemarkPlugins(LaTeXParsing)}
         rehypePlugins={getRehypePlugins()}
         components={getMarkdownComponents()}
         animate={animate}
diff --git a/client/src/components/Chat/Messages/Content/Part.tsx b/client/src/components/Chat/Messages/Content/Part.tsx
index e4a7168b149..70a7ade590c 100644
--- a/client/src/components/Chat/Messages/Content/Part.tsx
+++ b/client/src/components/Chat/Messages/Content/Part.tsx
@@ -80,6 +80,7 @@ const Part = memo(function Part({
       <SteerPart
         steer={part[ContentTypes.STEER]}
         files={part.files}
+        quotes={part.quotes}
         steerId={part.steerId}
         createdAt={part.createdAt}
       />
diff --git a/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx b/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx
index dc1ab443e27..1f02b793fb0 100644
--- a/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx
@@ -4,6 +4,7 @@ import { InfoHoverCard, ESide } from '@librechat/client';
 import type { TFile, TMessage } from 'librechat-data-provider';
 import FilePreviewDialog from '~/components/Chat/Messages/Content/FilePreviewDialog';
 import MessageTimestamp from '~/components/Chat/Messages/ui/MessageTimestamp';
+import MessageQuotes from '~/components/Chat/Messages/Content/MessageQuotes';
 import MarkdownLite from '~/components/Chat/Messages/Content/MarkdownLite';
 import FileContainer from '~/components/Chat/Input/Files/FileContainer';
 import Image from '~/components/Chat/Messages/Content/Image';
@@ -25,11 +26,15 @@ import store from '~/store';
 const SteerPart = memo(function SteerPart({
   steer,
   files,
+  quotes,
   steerId,
   createdAt,
 }: {
   steer: string;
   files?: TMessage['files'];
+  /** Quoted excerpts steered with the message; rendered as the same reference
+   *  blocks a user bubble shows for `message.quotes`. */
+  quotes?: string[];
   /** Anchors the part for the message-nav rail (`#steer-<id>` rib target). */
   steerId?: string;
   createdAt?: number;
@@ -83,6 +88,7 @@ const SteerPart = memo(function SteerPart({
       <div className="user-turn relative flex w-fit max-w-[90%] flex-col items-end sm:max-w-[85%]">
         <h2 className="sr-only">{label}</h2>
         <div className="flex max-w-full flex-col items-start gap-2 rounded-theme-surface rounded-br-theme-control bg-surface-tertiary px-theme-normal py-2.5">
+          <MessageQuotes quotes={quotes} />
           {(imageFiles.length > 0 || otherFiles.length > 0) && (
             <div className="flex flex-wrap gap-2">
               {otherFiles.map((file) => (
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx
index 65473de47d8..4f33780ea35 100644
--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx
@@ -165,4 +165,25 @@ describe('SteerPart presentation', () => {
     fireEvent.click(screen.getByTestId('steer-file'));
     expect(screen.getByTestId('steer-file-preview')).toHaveTextContent('notes.pdf');
   });
+
+  it('renders quoted excerpts as reference blocks inside the bubble', () => {
+    render(
+      <RecoilRoot initializeState={({ set }) => set(store.user, SEEDED_USER as never)}>
+        <SteerPart
+          steer="steered words"
+          steerId="s1"
+          createdAt={1}
+          quotes={['the selected excerpt']}
+        />
+      </RecoilRoot>,
+    );
+    const quotes = screen.getByTestId('message-quotes');
+    expect(quotes).toHaveTextContent('the selected excerpt');
+    expect(quotes.closest('.bg-surface-tertiary')).not.toBeNull();
+  });
+
+  it('renders no quote block when the steer carried none', () => {
+    renderPart();
+    expect(screen.queryByTestId('message-quotes')).toBeNull();
+  });
 });
diff --git a/client/src/components/Chat/Messages/Content/markdownConfig.ts b/client/src/components/Chat/Messages/Content/markdownConfig.ts
index 2d2483f52c3..6f07a5f53b7 100644
--- a/client/src/components/Chat/Messages/Content/markdownConfig.ts
+++ b/client/src/components/Chat/Messages/Content/markdownConfig.ts
@@ -1,3 +1,4 @@
+import 'katex/contrib/mhchem';
 import remarkGfm from 'remark-gfm';
 import remarkMath from 'remark-math';
 import supersub from 'remark-supersub';
@@ -12,9 +13,9 @@ import {
   MCPUIResourceCarousel,
 } from '~/components/MCPUIResource';
 import { Citation, CompositeCitation, HighlightedText } from '~/components/Web/Citation';
+import { langSubset, remarkApproxTilde, remarkSingleDollarMath } from '~/utils';
 import { Artifact, artifactPlugin } from '~/components/Artifacts/Artifact';
 import { code, a, p, img, table } from './MarkdownComponents';
-import { langSubset, remarkApproxTilde } from '~/utils';
 import { unicodeCitation } from '~/components/Web';
 
 /**
@@ -30,13 +31,19 @@ import { unicodeCitation } from '~/components/Web';
  * read to call time (when components render or memoize) sidesteps the
  * temporal dead zone.
  */
-export const getRemarkPlugins = (): PluggableList => [
+/**
+ * `latexParsing` (the user setting) gates only the ambiguous single-dollar syntax; the
+ * unambiguous `$$`, `\(...\)`, and `\[...\]` delimiters always parse via `remark-math`
+ * (aliased to `micromark-extension-llm-math` in vite and jest config).
+ */
+export const getRemarkPlugins = (latexParsing = true): PluggableList => [
   remarkApproxTilde,
   supersub,
   remarkGfm,
   remarkDirective,
   artifactPlugin,
   [remarkMath, { singleDollarTextMath: false }],
+  ...(latexParsing ? [remarkSingleDollarMath] : []),
   unicodeCitation,
   mcpUIResourcePlugin,
 ];
diff --git a/client/src/components/Chat/Messages/Content/splitMarkdown.ts b/client/src/components/Chat/Messages/Content/splitMarkdown.ts
index e5dfc9d23d3..21f8e75b67b 100644
--- a/client/src/components/Chat/Messages/Content/splitMarkdown.ts
+++ b/client/src/components/Chat/Messages/Content/splitMarkdown.ts
@@ -92,11 +92,12 @@ const countWithin = (
  * render pipeline relies on (GFM tables, container directives like
  * `:::artifact:::`, and `$$` math), so top-level block boundaries match what
  * react-markdown produces. Inline-only transforms (citations, MCP-UI markers,
- * supersub) never cross a top-level block, so they are intentionally omitted.
+ * supersub, single-dollar math) never cross a top-level block, so they are
+ * intentionally omitted.
  */
 const parseToMdast = (content: string): MdastNode =>
   fromMarkdown(content, {
-    extensions: [gfm(), directive(), math()],
+    extensions: [gfm(), directive(), math({ singleDollarTextMath: false })],
     mdastExtensions: [gfmFromMarkdown(), directiveFromMarkdown(), mathFromMarkdown()],
   }) as MdastNode;
 
diff --git a/client/src/data-provider/SSE/mutations.ts b/client/src/data-provider/SSE/mutations.ts
index 39e051e8b2f..77331d92095 100644
--- a/client/src/data-provider/SSE/mutations.ts
+++ b/client/src/data-provider/SSE/mutations.ts
@@ -171,6 +171,10 @@ export interface SteerMessageParams {
   text: string;
   /** Attachment refs steered with the message (already uploaded). */
   files?: TMessage['files'];
+  /** Quoted excerpts steered with the message ("Add to chat" selections). The
+   *  server normalizes them like a normal send's quotes and merges them into
+   *  the model-bound turn at the injection boundary. */
+  quotes?: string[];
   /**
    * Ask the server to seal the live model stream at the next provider-safe
    * boundary rather than waiting for a tool step. Never a rejection reason:
@@ -190,6 +194,10 @@ export interface SteerMessageResponse {
   /** Whether the seal request was actually armed; see {@link SteerMessageParams.preempt}. */
   preempt?: boolean;
   preemptRevision?: number;
+  /** Echoed when the durable item carries the sent quotes. Absent on a
+   *  pre-quotes server (which 202s while dropping them) — the client then
+   *  re-stages the excerpts as composer chips instead of losing them. */
+  quotesAccepted?: boolean;
   /** Receipt replay after this item already left the durable queue. */
   settled?: boolean;
   /** Settled specifically by terminal drain; restore as a queued follow-up. */
diff --git a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
index e8102ecc6fa..8892b5f4650 100644
--- a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
@@ -2052,6 +2052,7 @@ describe('useSteering', () => {
           chips: useRecoilValue(store.pendingSteersByConvoId(CONVO_ID)),
           pendingQuotes: useRecoilValue(store.pendingQuotesByConvoId(CONVO_ID)),
           pendingSkills: useRecoilValue(store.pendingManualSkillsByConvoId(CONVO_ID)),
+          markApplied: useSetRecoilState(store.appliedSteerIdsByConvoId(CONVO_ID)),
         }),
         { wrapper },
       );
@@ -2100,16 +2101,55 @@ describe('useSteering', () => {
       expect(result.current.pendingSkills).toEqual([]);
     });
 
-    it('leaves staged context untouched on the steer path (steers do not carry it)', () => {
+    it('steerFromComposer drains the quote chips into the POST, leaving skill picks staged', () => {
       const { result } = setupWithContext({}, stageContext);
       act(() => {
         result.current.steering.steerFromComposer('steer text');
       });
-      expect(mockMutate).toHaveBeenCalledTimes(1);
-      expect(result.current.pendingQuotes).toEqual(['quoted excerpt']);
+      expect(mockMutate).toHaveBeenCalledWith(
+        expect.objectContaining({ text: 'steer text', quotes: ['quoted excerpt'] }),
+        expect.anything(),
+      );
+      expect(mockMutate.mock.calls[0][0]).not.toHaveProperty('manualSkills');
+      // Consumed like a normal send's quotes; the excerpts now ride the steer.
+      expect(result.current.pendingQuotes).toEqual([]);
+      expect(result.current.chips[0]).toMatchObject({ quotes: ['quoted excerpt'] });
+      // A skill pick configures a NEW turn's run — it keeps waiting for one.
+      expect(result.current.pendingSkills).toEqual(['skill-1']);
+    });
+
+    it('interruptSteer carries the staged quotes the same way', () => {
+      const { result } = setupWithContext({}, stageContext);
+      act(() => {
+        result.current.steering.interruptSteer('stop and use this');
+      });
+      expect(mockMutate).toHaveBeenCalledWith(
+        expect.objectContaining({ quotes: ['quoted excerpt'], preempt: true }),
+        expect.anything(),
+      );
+      expect(result.current.pendingQuotes).toEqual([]);
       expect(result.current.pendingSkills).toEqual(['skill-1']);
     });
 
+    it("sendQueuedNow posts a queued item's quotes when steering it into the live run", () => {
+      const item: QueuedMessage = {
+        id: 'q-live',
+        text: 'queued with quotes',
+        createdAt: 1_000,
+        quotes: ['queued excerpt'],
+      };
+      const { result } = setupWithContext({}, ({ set }) => {
+        set(store.queuedMessagesByConvoId(CONVO_ID), [item]);
+      });
+      act(() => {
+        result.current.steering.sendQueuedNow(item);
+      });
+      expect(mockMutate).toHaveBeenCalledWith(
+        expect.objectContaining({ text: 'queued with quotes', quotes: ['queued excerpt'] }),
+        expect.anything(),
+      );
+    });
+
     it('queues without quotes/skills fields when nothing is staged', () => {
       const { result } = setupWithContext();
       act(() => {
@@ -2207,7 +2247,13 @@ describe('useSteering', () => {
 
     it('carries a queued-origin context onto the sending chip and the 202 ACK chip', () => {
       mockMutate.mockImplementationOnce((_params, { onSuccess }) => {
-        onSuccess({ steerId: 'srv-ctx', status: 'queued', position: 1, conversationId: CONVO_ID });
+        onSuccess({
+          steerId: 'srv-ctx',
+          status: 'queued',
+          position: 1,
+          conversationId: CONVO_ID,
+          quotesAccepted: true,
+        });
       });
       const { result } = setupWithContext();
       act(() => {
@@ -2226,6 +2272,145 @@ describe('useSteering', () => {
       ]);
     });
 
+    it('keeps rejected quotes carried on the pending chip (old-server ACK)', () => {
+      // A pre-quotes replica 202s the words without their excerpts, but the
+      // steer has NOT injected yet — the quotes must stay attached to the
+      // words: a later quote-less applied event re-stages them at the actual
+      // loss, while a terminal leftover conversion carries them onto the
+      // recovered row (whose normal send delivers quotes on any server).
+      // Re-staging at the ACK would let that leftover auto-send bare text
+      // while the excerpts glue onto an unrelated composer draft.
+      mockMutate.mockImplementationOnce((_params, { onSuccess }) => {
+        onSuccess({ steerId: 'srv-old', status: 'queued', position: 1, conversationId: CONVO_ID });
+      });
+      const { result } = setupWithContext({}, stageContext);
+      act(() => {
+        result.current.steering.steerFromComposer('quoted for an old server');
+      });
+      expect(result.current.pendingQuotes).toEqual([]);
+      expect(result.current.chips).toEqual([
+        expect.objectContaining({
+          steerId: 'srv-old',
+          status: 'pending',
+          quotes: ['quoted excerpt'],
+        }),
+      ]);
+    });
+
+    it('keeps quotes drained when the ACK confirms they were accepted', () => {
+      mockMutate.mockImplementationOnce((_params, { onSuccess }) => {
+        onSuccess({
+          steerId: 'srv-new',
+          status: 'queued',
+          position: 1,
+          conversationId: CONVO_ID,
+          quotesAccepted: true,
+        });
+      });
+      const { result } = setupWithContext({}, stageContext);
+      act(() => {
+        result.current.steering.steerFromComposer('quoted for a new server');
+      });
+      expect(result.current.pendingQuotes).toEqual([]);
+      expect(result.current.chips[0]).toMatchObject({
+        steerId: 'srv-new',
+        quotes: ['quoted excerpt'],
+      });
+    });
+
+    it("keeps a queued item's quotes on its chip when Send now hits an old server", () => {
+      // The pending chip and its captured origin retain the quotes so every
+      // later outcome preserves them with the words: a quote-less applied
+      // event re-stages, a leftover conversion restores the exact row, and a
+      // reclaim hands them back to the composer.
+      mockMutate.mockImplementationOnce((_params, { onSuccess }) => {
+        onSuccess({
+          steerId: 'srv-q-old',
+          status: 'queued',
+          position: 1,
+          conversationId: CONVO_ID,
+        });
+      });
+      const item: QueuedMessage = {
+        id: 'q-old-server',
+        text: 'queued quoted words',
+        createdAt: 1_000,
+        quotes: ['queued excerpt'],
+      };
+      const { result } = setupWithContext({}, ({ set }) => {
+        set(store.queuedMessagesByConvoId(CONVO_ID), [item]);
+      });
+      act(() => {
+        result.current.steering.sendQueuedNow(item);
+      });
+      expect(result.current.queue).toEqual([]);
+      expect(result.current.pendingQuotes).toEqual([]);
+      const chip = result.current.chips[0];
+      expect(chip).toMatchObject({
+        steerId: 'srv-q-old',
+        status: 'pending',
+        quotes: ['queued excerpt'],
+      });
+      expect(chip.queuedOrigin?.item.quotes).toEqual(['queued excerpt']);
+    });
+
+    it('never re-stages quotes a terminal conversion already moved to the queue', () => {
+      // A pre-quotes server's run-end leftover event converts the chip (with
+      // its quotes) into a queued follow-up and marks the ids applied BEFORE
+      // the delayed no-echo 202 lands. The reclaim must find no surviving chip
+      // and leave the queued copy as the single owner of the excerpts.
+      let deferredOnSuccess: ((response: unknown) => void) | undefined;
+      mockMutate.mockImplementationOnce((_params, { onSuccess }) => {
+        deferredOnSuccess = onSuccess;
+      });
+      const { result } = setupWithContext({}, stageContext);
+      act(() => {
+        result.current.steering.steerFromComposer('converted before ACK');
+      });
+      const localId = result.current.chips[0].steerId;
+      act(() => {
+        result.current.markApplied((prev) => [...prev, localId]);
+        result.current.steering.convertSteerToQueue(localId, 'converted before ACK', undefined, {
+          quotes: ['quoted excerpt'],
+        });
+      });
+      expect(result.current.queue[0]).toMatchObject({ quotes: ['quoted excerpt'] });
+      act(() => {
+        deferredOnSuccess?.({
+          steerId: 'srv-converted',
+          status: 'queued',
+          position: 1,
+          conversationId: CONVO_ID,
+        });
+      });
+      // No re-mint, no re-stage: the queued follow-up remains the only copy.
+      expect(result.current.chips).toEqual([]);
+      expect(result.current.pendingQuotes).toEqual([]);
+      expect(result.current.queue).toHaveLength(1);
+    });
+
+    it('re-stages quotes on a settled receipt replay that never carried them', () => {
+      // Lost first ACK against an old replica; the retry's receipt replay
+      // (settled, already injected) proves the excerpts never attached.
+      mockMutate.mockImplementationOnce((_params, { onSuccess }) => {
+        onSuccess({
+          steerId: 'srv-replayed',
+          status: 'queued',
+          position: 1,
+          conversationId: CONVO_ID,
+          settled: true,
+          replayed: true,
+          generationProtocolVersion: 2,
+        });
+      });
+      const { result } = setupWithContext({}, stageContext);
+      act(() => {
+        result.current.steering.steerFromComposer('replayed without quotes');
+      });
+      expect(result.current.pendingQuotes).toEqual(['quoted excerpt']);
+      expect(result.current.chips).toEqual([]);
+    });
+
     it('restores the carried context when a late ACK converts straight to queued', () => {
       // The run ended before the 202 landed: the ACK's queued conversion is
       // the only surviving copy of the steer, so it must keep quotes + skills.
@@ -2325,6 +2510,7 @@ describe('useSteering', () => {
           status: 'queued',
           position: 1,
           conversationId: CONVO_ID,
+          quotesAccepted: true,
         });
       });
       act(() => {
@@ -2346,7 +2532,7 @@ describe('useSteering', () => {
       ]);
     });
 
-    it('leaves composer atoms staged when a composer-origin steer degrades', () => {
+    it('requeues a degraded composer-origin steer with its drained quotes', () => {
       mockMutate.mockImplementationOnce((_params, { onError }) => {
         onError({ response: { data: { code: 'RUN_PAUSED' } } });
       });
@@ -2354,12 +2540,14 @@ describe('useSteering', () => {
       act(() => {
         result.current.steering.steerFromComposer('degraded steer');
       });
-      // Degrades to a text-only queued item; the staged chips stay put for
-      // the user's next composer send.
-      expect(result.current.queue).toEqual([expect.objectContaining({ text: 'degraded steer' })]);
-      expect(result.current.queue[0].quotes).toBeUndefined();
+      // The quotes were consumed into the steer, so its queued fallback must
+      // carry them — dropping them here would lose the user's references.
+      expect(result.current.queue).toEqual([
+        expect.objectContaining({ text: 'degraded steer', quotes: ['quoted excerpt'] }),
+      ]);
       expect(result.current.queue[0].manualSkills).toBeUndefined();
-      expect(result.current.pendingQuotes).toEqual(['quoted excerpt']);
+      expect(result.current.pendingQuotes).toEqual([]);
+      // Skill picks were never consumed and stay staged for the next send.
       expect(result.current.pendingSkills).toEqual(['skill-1']);
     });
   });
diff --git a/client/src/hooks/Chat/useSteerConvert.ts b/client/src/hooks/Chat/useSteerConvert.ts
index 59229566d19..df6ecc22b5f 100644
--- a/client/src/hooks/Chat/useSteerConvert.ts
+++ b/client/src/hooks/Chat/useSteerConvert.ts
@@ -64,8 +64,10 @@ export default function useSteerConvert() {
             .getLoadable(store.activeGenerationProtocolVersionByConvoId(conversationId))
             .getValue();
         const bindRecoverySource = negotiatedVersion === 2;
-        // Quotes/skill picks never ride the server steer; restore them from
-        // the local chip (matched by id) before the chips are dropped below.
+        // Restore quotes/skill picks from the local chip (matched by id)
+        // before the chips are dropped below: the chip is the only carrier of
+        // skill picks, and of quotes accepted by an older server whose queue
+        // items did not persist them yet.
         const localChips = snapshot
           .getLoadable(store.pendingSteersByConvoId(conversationId))
           .getValue();
diff --git a/client/src/hooks/Chat/useSteering.ts b/client/src/hooks/Chat/useSteering.ts
index fd471a5fb64..6eb4ca7225e 100644
--- a/client/src/hooks/Chat/useSteering.ts
+++ b/client/src/hooks/Chat/useSteering.ts
@@ -20,6 +20,7 @@ import {
   clearAllDrafts,
   getPendingDraftId,
   insertQueuedOrigin,
+  mergeRestagedQuotes,
 } from '~/utils';
 import useSteerConvert from '~/hooks/Chat/useSteerConvert';
 import { useSetFilesToDelete } from '~/hooks/Files';
@@ -622,6 +623,69 @@ export default function useSteering({
     [conversationId],
   );
 
+  /** Quotes-only drain for composer-origin steers: the excerpts ride the steer
+   *  POST into the live run, while manual skill picks stay staged — a skill
+   *  pick configures a NEW turn's agent run and cannot apply to a mid-run
+   *  injection, so it keeps waiting for the next full submission. */
+  const takeComposerQuotes = useRecoilCallback(
+    ({ snapshot, reset }) =>
+      (): QueuedMessageContext => {
+        const quotes = snapshot
+          .getLoadable(store.pendingQuotesByConvoId(conversationId))
+          .getValue();
+        if (quotes.length === 0) {
+          return {};
+        }
+        reset(store.pendingQuotesByConvoId(conversationId));
+        return { quotes };
+      },
+    [conversationId],
+  );
+
+  /** Returns rejected excerpts to the composer chips from the SURVIVING steer
+   *  chip — used ONLY for a settled receipt replay, where the steer already
+   *  injected in the source generation and no future applied event or
+   *  terminal conversion will ever re-home the chip's quotes. An ordinary
+   *  no-echo ACK deliberately does NOT reclaim: its steer is still queued, so
+   *  the quotes stay carried on the pending chip — the applied-event
+   *  reconciliation re-stages them at the actual moment of loss, while a
+   *  terminal leftover conversion moves them onto the recovered row, which
+   *  sends via `ask` where quotes work on any server. When no chip remains,
+   *  another path already owns the excerpts and re-staging would
+   *  double-deliver. The chip is stripped in the same update (including its
+   *  captured queue-origin copy) so the restaged composer chips stay their
+   *  single representation. */
+  const reclaimRejectedChipQuotes = useRecoilCallback(
+    ({ snapshot, set }) =>
+      (convoId: string, steerIds: string[]) => {
+        const chips = snapshot.getLoadable(store.pendingSteersByConvoId(convoId)).getValue();
+        const chip = chips.find((steer) => steerIds.includes(steer.steerId));
+        const quotes = chip?.quotes ?? chip?.queuedOrigin?.item.quotes;
+        if (quotes == null || quotes.length === 0) {
+          return;
+        }
+        set(store.pendingQuotesByConvoId(convoId), (prev) => mergeRestagedQuotes(prev, quotes));
+        set(store.pendingSteersByConvoId(convoId), (prev) => {
+          let changed = false;
+          const next = prev.map((steer) => {
+            const originHasQuotes = steer.queuedOrigin?.item.quotes != null;
+            if (!steerIds.includes(steer.steerId) || (steer.quotes == null && !originHasQuotes)) {
+              return steer;
+            }
+            changed = true;
+            const { quotes: _quotes, ...rest } = steer;
+            if (!originHasQuotes || rest.queuedOrigin == null) {
+              return rest;
+            }
+            const { quotes: _originQuotes, ...originItem } = rest.queuedOrigin.item;
+            return { ...rest, queuedOrigin: { ...rest.queuedOrigin, item: originItem } };
+          });
+          return changed ? next : prev;
+        });
+      },
+    [],
+  );
+
   /** Consumes the composer's autosaved draft once its text has been taken into
    *  a steer or queued item. The composer clears via the form's `reset()`,
    *  which is programmatic and never fires the `input` event `useAutoSave`
@@ -853,11 +917,12 @@ export default function useSteering({
     [index, queueKey, activeGenerationCreatedAt],
   );
 
-  /** POSTs a steer (text + files only; the server never carries quotes or
-   *  skill picks). `context` is the RESTORE payload for a queued-origin steer:
-   *  every degradation path threads it back into the requeue/send fallback so
-   *  the item's quotes and manual skills survive. Composer-origin steers pass
-   *  nothing, leaving their context staged in the composer atoms. */
+  /** POSTs a steer (text + files + quotes; the server merges the quotes into
+   *  the model-bound turn at the injection boundary). `context` doubles as the
+   *  RESTORE payload: every degradation path threads it back into the
+   *  requeue/send fallback so the item's quotes and manual skills survive.
+   *  Skill picks never ride the POST — they configure a NEW turn's run, so a
+   *  queued-origin steer only carries them for restoration. */
   const submitSteer = useCallback(
     (
       text: string,
@@ -951,6 +1016,7 @@ export default function useSteering({
             clientSteerId: localId,
             text: trimmed,
             ...(files && { files }),
+            ...(carried.quotes && { quotes: carried.quotes }),
             ...(preempt && { preempt }),
             ...(targetGenerationCreatedAt != null && {
               generationCreatedAt: targetGenerationCreatedAt,
@@ -959,6 +1025,16 @@ export default function useSteering({
           {
             onSuccess: (response) => {
               try {
+                /** A 202 without the echo means a pre-quotes replica queued
+                 *  the words without their excerpts. The quotes are NOT
+                 *  re-staged here — the steer has not injected yet, so they
+                 *  stay carried on the pending chip: a quote-less applied
+                 *  event re-stages them at the actual loss, and a terminal
+                 *  leftover conversion carries them onto the recovered row
+                 *  instead (its normal send delivers quotes on any server).
+                 *  Only a settled replay — an already-injected steer with no
+                 *  future event to re-home the chip — reclaims immediately. */
+                const quotesRejected = carried.quotes != null && response.quotesAccepted !== true;
                 const canUseV2Receipt =
                   targetGenerationProtocolVersion === 2 && supportsGenerationProtocolV2(response);
                 if (canUseV2Receipt && response.settled === true) {
@@ -978,6 +1054,9 @@ export default function useSteering({
                       ...carried,
                     });
                   } else {
+                    if (quotesRejected) {
+                      reclaimRejectedChipQuotes(conversationId, [localId, response.steerId]);
+                    }
                     settleReceiptReplay(conversationId, localId, response.steerId);
                   }
                   return;
@@ -1005,6 +1084,9 @@ export default function useSteering({
                   ...carried,
                 } satisfies PendingSteer;
                 if (acknowledgeSteer(conversationId, localId, acknowledged)) {
+                  /** Terminal conversion re-homes the words as a queued
+                   *  follow-up that sends via `ask` — the carried quotes ride
+                   *  it there, so nothing is re-staged. */
                   queueRecoveredSteer(acknowledged);
                 }
               } finally {
@@ -1128,6 +1210,7 @@ export default function useSteering({
       acknowledgeSteer,
       settleReceiptReplay,
       queueRecoveredSteer,
+      reclaimRejectedChipQuotes,
       steerMessage,
       sendNow,
       enqueue,
@@ -1143,22 +1226,26 @@ export default function useSteering({
     ],
   );
 
-  /** Composer-originated steer: consumes the composer's attachments so they
-   *  ride the steer as one unit (the server re-fetches + encodes them at the
-   *  injection boundary). Files are taken only after the guards pass. */
+  /** Composer-originated steer: consumes the composer's attachments and quote
+   *  chips so they ride the steer as one unit (the server re-fetches + encodes
+   *  files and merges quotes at the injection boundary). Both are taken only
+   *  after the guards pass — with `canSteer` true, `submitSteer` cannot
+   *  refuse, so the drained context can never be stranded. */
   const steerFromComposer = useCallback(
     (text: string, preempt = false): boolean => {
       const trimmed = text.trim();
       if (trimmed.length === 0 || filesLoading || !canSteer) {
         return false;
       }
-      const consumed = submitSteer(trimmed, takeComposerFiles(), undefined, { preempt });
+      const consumed = submitSteer(trimmed, takeComposerFiles(), takeComposerQuotes(), {
+        preempt,
+      });
       if (consumed) {
         takeComposerDraft();
       }
       return consumed;
     },
-    [filesLoading, canSteer, takeComposerFiles, takeComposerDraft, submitSteer],
+    [filesLoading, canSteer, takeComposerFiles, takeComposerQuotes, takeComposerDraft, submitSteer],
   );
 
   /** Composer-originated queue: carries the composer's attachments, quote
@@ -1398,7 +1485,9 @@ export default function useSteering({
       if (!hasRealConvoId) {
         return interruptAndSend(trimmed);
       }
-      const consumed = submitSteer(trimmed, takeComposerFiles(), undefined, { preempt: true });
+      const consumed = submitSteer(trimmed, takeComposerFiles(), takeComposerQuotes(), {
+        preempt: true,
+      });
       if (consumed) {
         takeComposerDraft();
       }
@@ -1411,6 +1500,7 @@ export default function useSteering({
       hasRealConvoId,
       interruptAndSend,
       takeComposerFiles,
+      takeComposerQuotes,
       takeComposerDraft,
       submitSteer,
     ],
diff --git a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts
index 514f6b64562..74d29063588 100644
--- a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts
+++ b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts
@@ -2429,8 +2429,22 @@ describe('useResumableSSE', () => {
       });
     }
 
-    expect(mockResolveSteerChip).toHaveBeenNthCalledWith(1, CONV_ID, 'server-1', 'client-1');
-    expect(mockResolveSteerChip).toHaveBeenNthCalledWith(2, CONV_ID, 'server-2', 'client-2');
+    // 4th arg: the applied part's quotes (absent here) — see the pre-quotes
+    // server restage in resolveSteerChip.
+    expect(mockResolveSteerChip).toHaveBeenNthCalledWith(
+      1,
+      CONV_ID,
+      'server-1',
+      'client-1',
+      undefined,
+    );
+    expect(mockResolveSteerChip).toHaveBeenNthCalledWith(
+      2,
+      CONV_ID,
+      'server-2',
+      'client-2',
+      undefined,
+    );
     expect(requestFrame).toHaveBeenCalledTimes(2);
 
     await act(async () => {
diff --git a/client/src/hooks/SSE/useResumableSSE.ts b/client/src/hooks/SSE/useResumableSSE.ts
index 64aa5bda93c..e1eb9df81d3 100644
--- a/client/src/hooks/SSE/useResumableSSE.ts
+++ b/client/src/hooks/SSE/useResumableSSE.ts
@@ -54,6 +54,8 @@ import {
   findReasoningLabelMessageIndex,
   appendAppliedSteerIds,
   collectAppliedSteerIds,
+  collectDroppedSteerQuotes,
+  mergeRestagedQuotes,
   removeConvoFromAllQueries,
   upsertConvoInAllQueries,
   countTaggedApprovalParts,
@@ -857,9 +859,32 @@ export default function useResumableSSE(
    *  part becomes the durable record), and records the id so a 202 ACK that
    *  arrives AFTER the applied event drops its chip instead of re-minting it. */
   const resolveSteerChip = useRecoilCallback(
-    ({ set }) =>
-      (conversationId: string, steerId: string, clientSteerId?: string) => {
+    ({ snapshot, set }) =>
+      (
+        conversationId: string,
+        steerId: string,
+        clientSteerId?: string,
+        appliedPartQuotes?: string[],
+      ) => {
         const settledIds = clientSteerId ? [steerId, clientSteerId] : [steerId];
+        /** A part applied by a pre-quotes server carries no quotes while the
+         *  chip being settled may hold the only copy of the user's excerpts
+         *  (its 202 was lost, so the ACK-echo restore never ran). Re-stage
+         *  them before removal; `mergeRestagedQuotes` keeps this idempotent
+         *  with the ACK path for the same excerpts. */
+        if (appliedPartQuotes == null || appliedPartQuotes.length === 0) {
+          const chips = snapshot
+            .getLoadable(store.pendingSteersByConvoId(conversationId))
+            .getValue();
+          const droppedQuotes = chips.find(
+            (steer) => settledIds.includes(steer.steerId) && (steer.quotes?.length ?? 0) > 0,
+          )?.quotes;
+          if (droppedQuotes != null && droppedQuotes.length > 0) {
+            set(store.pendingQuotesByConvoId(conversationId), (prev) =>
+              mergeRestagedQuotes(prev, droppedQuotes),
+            );
+          }
+        }
         set(store.appliedSteerIdsByConvoId(conversationId), (prev) =>
           appendAppliedSteerIds(prev, settledIds),
         );
@@ -960,7 +985,8 @@ export default function useResumableSSE(
 
   /** Replaces the chip list with the server's still-queued steers (reconnect).
    *  Local `failed` entries are kept so their text stays recoverable, and a
-   *  reseeded chip keeps its client-only quotes/skill picks. */
+   *  reseeded chip keeps its quotes/skill picks (from the local chip, or the
+   *  server item's persisted quotes when no chip survives). */
   const seedSteerChips = useRecoilCallback(
     ({ set }) =>
       (
@@ -1013,7 +1039,10 @@ export default function useResumableSSE(
                   generationCreatedAt: chipGenerationCreatedAt,
                 }),
                 generationProtocolVersion,
-                ...carriedSteerContext(localChip),
+                // The local chip carries skill picks the server never sees; a
+                // fresh tab has no chip, so fall back to the server item's
+                // persisted quotes rather than reseeding the chip without them.
+                ...carriedSteerContext(localChip ?? steer),
               };
             }),
             ...prev.filter((steer) => steer.status === 'failed' && !claimedIds.has(steer.steerId)),
@@ -1024,13 +1053,25 @@ export default function useResumableSSE(
   );
 
   const settleAppliedSteerParts = useRecoilCallback(
-    ({ set }) =>
+    ({ snapshot, set }) =>
       (conversationId: string, values: unknown[] | undefined) => {
         const ids = collectAppliedSteerIds(values);
         if (ids.length === 0) {
           return;
         }
         const settled = new Set(ids);
+        /** Chips settled by quote-less applied parts hold the only copy of
+         *  their excerpts (a pre-quotes server injected the words bare) —
+         *  re-stage them as composer chips before the removal below. */
+        const droppedQuotes = collectDroppedSteerQuotes(
+          values,
+          snapshot.getLoadable(store.pendingSteersByConvoId(conversationId)).getValue(),
+        );
+        if (droppedQuotes.length > 0) {
+          set(store.pendingQuotesByConvoId(conversationId), (prev) =>
+            mergeRestagedQuotes(prev, droppedQuotes),
+          );
+        }
         set(store.appliedSteerIdsByConvoId(conversationId), (prev) =>
           appendAppliedSteerIds(prev, ids),
         );
@@ -1387,7 +1428,7 @@ export default function useResumableSSE(
          *  the chip pending during that wait lets an intervening error/final
          *  convert already-applied words into a duplicate queued message. */
         if (attempt === 0) {
-          resolveSteerChip(chipConvoId, event.steerId, event.clientSteerId);
+          resolveSteerChip(chipConvoId, event.steerId, event.clientSteerId, event.part?.quotes);
         }
         const retryNextFrame = () => {
           if (attempt < PENDING_ACTION_MAX_RETRY_FRAMES) {
diff --git a/client/src/hooks/SSE/useResumeOnLoad.ts b/client/src/hooks/SSE/useResumeOnLoad.ts
index f68baee9348..6d6bad01d3e 100644
--- a/client/src/hooks/SSE/useResumeOnLoad.ts
+++ b/client/src/hooks/SSE/useResumeOnLoad.ts
@@ -14,6 +14,8 @@ import {
   dedupeSteersById,
   appendAppliedSteerIds,
   collectAppliedSteerIds,
+  collectDroppedSteerQuotes,
+  mergeRestagedQuotes,
   applyPendingAction,
   carriedSteerContext,
   getBranchSiblingIndexesForTarget,
@@ -354,7 +356,10 @@ export default function useResumeOnLoad(
                   generationCreatedAt: chipGenerationCreatedAt,
                 }),
                 generationProtocolVersion,
-                ...carriedSteerContext(localChip),
+                // The local chip carries skill picks the server never sees; a
+                // fresh tab has no chip, so fall back to the server item's
+                // persisted quotes rather than reseeding the chip without them.
+                ...carriedSteerContext(localChip ?? steer),
               };
             }),
             ...prev.filter((steer) => steer.status === 'failed' && !claimedIds.has(steer.steerId)),
@@ -365,13 +370,25 @@ export default function useResumeOnLoad(
   );
 
   const settleAppliedSteerParts = useRecoilCallback(
-    ({ set }) =>
+    ({ snapshot, set }) =>
       (activeConversationId: string, values: unknown[] | undefined) => {
         const ids = collectAppliedSteerIds(values);
         if (ids.length === 0) {
           return;
         }
         const settled = new Set(ids);
+        /** Chips settled by quote-less applied parts hold the only copy of
+         *  their excerpts (a pre-quotes server injected the words bare) —
+         *  re-stage them as composer chips before the removal below. */
+        const droppedQuotes = collectDroppedSteerQuotes(
+          values,
+          snapshot.getLoadable(store.pendingSteersByConvoId(activeConversationId)).getValue(),
+        );
+        if (droppedQuotes.length > 0) {
+          set(store.pendingQuotesByConvoId(activeConversationId), (prev) =>
+            mergeRestagedQuotes(prev, droppedQuotes),
+          );
+        }
         set(store.appliedSteerIdsByConvoId(activeConversationId), (prev) =>
           appendAppliedSteerIds(prev, ids),
         );
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 8350bc740a1..1b16c3ed040 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -1780,6 +1780,7 @@
   "com_ui_queue_send": "Queue message for after the response",
   "com_ui_queued_attachment_count": "{{0}} attachments queued with this message",
   "com_ui_queued_messages": "Queued messages",
+  "com_ui_queued_quote_count": "{{0}} quoted excerpts included with this message",
   "com_ui_quote_selections": "{{0}} selections",
   "com_ui_quotes_queued": "Quotes added for your next message",
   "com_ui_ran_n_agents": "Ran {{0}} agents",
diff --git a/client/src/store/families.ts b/client/src/store/families.ts
index 53a9e1522ec..e3956516bca 100644
--- a/client/src/store/families.ts
+++ b/client/src/store/families.ts
@@ -350,10 +350,12 @@ export type PendingSteer = {
   createdAt: number;
   /** Attachments steered with the message (refs; already uploaded). */
   files?: TMessage['files'];
-  /** Quote chips carried by a queued-origin steer (client-only; never sent to
-   *  the server), restored onto the queued item if the run ends first. */
+  /** Quoted excerpts riding this steer (also sent on the POST — the server
+   *  merges them into the injected turn); kept on the chip so a steer that
+   *  never injects restores onto the queued item with them intact. */
   quotes?: string[];
-  /** Manual skill picks carried the same way as `quotes`. */
+  /** Manual skill picks, carried for restoration only (a skill pick
+   *  configures a NEW turn's run, so it never rides the steer POST). */
   manualSkills?: string[];
   /** Asked the run to seal generation at the next safe boundary rather than
    *  wait for a tool step. Labelling only — the server owns the behaviour and
diff --git a/client/src/utils/__tests__/steer.spec.ts b/client/src/utils/__tests__/steer.spec.ts
index 46dc8924faf..971b26e081c 100644
--- a/client/src/utils/__tests__/steer.spec.ts
+++ b/client/src/utils/__tests__/steer.spec.ts
@@ -8,6 +8,8 @@ import {
   appendAppliedSteerIds,
   resolveAbortSteerTarget,
   insertQueuedOrigin,
+  mergeRestagedQuotes,
+  collectDroppedSteerQuotes,
 } from '../steer';
 
 const buildEvent = (overrides: Partial<TSteerAppliedEvent> = {}): TSteerAppliedEvent => ({
@@ -218,3 +220,56 @@ describe('insertQueuedOrigin', () => {
     ]);
   });
 });
+
+describe('mergeRestagedQuotes', () => {
+  it('appends only fresh excerpts and keeps referential stability when none land', () => {
+    const prev = ['kept'];
+    expect(mergeRestagedQuotes(prev, ['kept'])).toBe(prev);
+    expect(mergeRestagedQuotes(prev, ['kept', 'new'])).toEqual(['kept', 'new']);
+  });
+
+  it('never grows past the sendable cap, letting already-staged chips win', () => {
+    // A chip beyond MAX_QUOTE_COUNT would render but silently miss the next
+    // send (both ends keep only the first 10) — drop the overflow explicitly.
+    const staged = Array.from({ length: 9 }, (_, i) => `staged-${i}`);
+    expect(mergeRestagedQuotes(staged, ['restored-a', 'restored-b'])).toEqual([
+      ...staged,
+      'restored-a',
+    ]);
+    const full = Array.from({ length: 10 }, (_, i) => `staged-${i}`);
+    expect(mergeRestagedQuotes(full, ['restored-a'])).toBe(full);
+  });
+});
+
+describe('collectDroppedSteerQuotes', () => {
+  const chips = [
+    { steerId: 'srv-1', clientSteerId: 'local-1', quotes: ['excerpt one'] },
+    { steerId: 'srv-2', quotes: ['excerpt two'] },
+    { steerId: 'srv-3' },
+  ];
+
+  it('collects quotes for chips whose applied part carries none', () => {
+    const values = [
+      {
+        content: [
+          { type: ContentTypes.STEER, steerId: 'srv-1' },
+          { type: ContentTypes.STEER, steerId: 'srv-2', quotes: ['excerpt two'] },
+          { type: ContentTypes.STEER, steerId: 'srv-3' },
+        ],
+      },
+    ];
+    expect(collectDroppedSteerQuotes(values, chips)).toEqual(['excerpt one']);
+  });
+
+  it('matches a quote-less part by the client correlation id too', () => {
+    const values = [{ content: [{ type: ContentTypes.STEER, clientSteerId: 'local-1' }] }];
+    expect(collectDroppedSteerQuotes(values, chips)).toEqual(['excerpt one']);
+  });
+
+  it('returns nothing when every applied part kept its quotes', () => {
+    const values = [
+      { content: [{ type: ContentTypes.STEER, steerId: 'srv-1', quotes: ['excerpt one'] }] },
+    ];
+    expect(collectDroppedSteerQuotes(values, chips)).toEqual([]);
+  });
+});
diff --git a/client/src/utils/latex.spec.ts b/client/src/utils/latex.spec.ts
index f044f4de531..49c18f1d2f6 100644
--- a/client/src/utils/latex.spec.ts
+++ b/client/src/utils/latex.spec.ts
@@ -1,254 +1,314 @@
-import { preprocessLaTeX } from './latex';
-
-describe('preprocessLaTeX', () => {
-  test('returns the same string if no LaTeX patterns are found', () => {
-    const content = 'This is a test string without LaTeX or dollar signs';
-    expect(preprocessLaTeX(content)).toBe(content);
-  });
-
-  test('returns the same string if no dollar signs are present', () => {
-    const content = 'This has LaTeX \\(x^2\\) and \\[y^2\\] but no dollars';
-    expect(preprocessLaTeX(content)).toBe(content);
-  });
-
-  test('preserves valid inline LaTeX delimiters \\(...\\)', () => {
-    const content = 'This is inline LaTeX: \\(x^2 + y^2 = z^2\\)';
-    expect(preprocessLaTeX(content)).toBe(content);
-  });
-
-  test('preserves valid block LaTeX delimiters \\[...\\]', () => {
-    const content = 'This is block LaTeX: \\[E = mc^2\\]';
-    expect(preprocessLaTeX(content)).toBe(content);
-  });
-
-  test('preserves valid double dollar delimiters', () => {
-    const content = 'This is valid: $$x^2 + y^2 = z^2$$';
-    expect(preprocessLaTeX(content)).toBe(content);
-  });
-
-  test('converts single dollar delimiters to double dollars', () => {
-    const content = 'Inline math: $x^2 + y^2 = z^2$';
-    const expected = 'Inline math: $$x^2 + y^2 = z^2$$';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('converts multiple single dollar expressions', () => {
-    const content = 'First $a + b = c$ and second $x^2 + y^2 = z^2$';
-    const expected = 'First $$a + b = c$$ and second $$x^2 + y^2 = z^2$$';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('escapes currency dollar signs', () => {
-    const content = 'Price is $50 and $100';
-    const expected = 'Price is \\$50 and \\$100';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('escapes currency with spaces', () => {
-    const content = '$50 is $20 + $30';
-    const expected = '\\$50 is \\$20 + \\$30';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('escapes currency with commas', () => {
-    const content = 'The price is $1,000,000 for this item.';
-    const expected = 'The price is \\$1,000,000 for this item.';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('escapes currency with decimals', () => {
-    const content = 'Total: $29.50 plus tax';
-    const expected = 'Total: \\$29.50 plus tax';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('converts LaTeX expressions while escaping currency', () => {
-    const content = 'LaTeX $x^2$ and price $50';
-    const expected = 'LaTeX $$x^2$$ and price \\$50';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles Goldbach Conjecture example', () => {
-    const content = '- **Goldbach Conjecture**: $2n = p + q$ (every even integer > 2)';
-    const expected = '- **Goldbach Conjecture**: $$2n = p + q$$ (every even integer > 2)';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('does not escape already escaped dollar signs', () => {
-    const content = 'Already escaped \\$50 and \\$100';
-    expect(preprocessLaTeX(content)).toBe(content);
-  });
-
-  test('does not convert already escaped single dollars', () => {
-    const content = 'Escaped \\$x^2\\$ should not change';
-    expect(preprocessLaTeX(content)).toBe(content);
-  });
-
-  test('escapes mhchem commands', () => {
-    const content = '$\\ce{H2O}$ and $\\pu{123 J}$';
-    const expected = '$$\\\\ce{H2O}$$ and $$\\\\pu{123 J}$$';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles empty string', () => {
-    expect(preprocessLaTeX('')).toBe('');
-  });
-
-  test('handles complex mixed content', () => {
-    const content = `Valid double $$y^2$$
-Currency $100 and $200
-Single dollar math $x^2 + y^2$
-Chemical $\\ce{H2O}$
-Valid brackets \\[z^2\\]`;
-    const expected = `Valid double $$y^2$$
-Currency \\$100 and \\$200
-Single dollar math $$x^2 + y^2$$
-Chemical $$\\\\ce{H2O}$$
-Valid brackets \\[z^2\\]`;
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles multiple equations with currency', () => {
-    const content = `- **Euler's Totient Function**: $\\phi(n) = n \\prod_{p|n} \\left(1 - \\frac{1}{p}\\right)$
-- **Total Savings**: $500 + $200 + $150 = $850`;
-    const expected = `- **Euler's Totient Function**: $$\\phi(n) = n \\prod_{p|n} \\left(1 - \\frac{1}{p}\\right)$$
-- **Total Savings**: \\$500 + \\$200 + \\$150 = \\$850`;
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles inline code blocks', () => {
-    const content = 'Outside $x^2$ and inside code: `$100`';
-    const expected = 'Outside $$x^2$$ and inside code: `$100`';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles multiline code blocks', () => {
-    const content = '```\n$100\n$variable\n```\nOutside $x^2$';
-    const expected = '```\n$100\n$variable\n```\nOutside $$x^2$$';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('preserves LaTeX expressions with special characters', () => {
-    const content = 'The set is defined as $\\{x | x > 0\\}$.';
-    const expected = 'The set is defined as $$\\{x | x > 0\\}$$.';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles complex physics equations', () => {
-    const content = `- **Schrödinger Equation**: $i\\hbar\\frac{\\partial}{\\partial t}|\\psi\\rangle = \\hat{H}|\\psi\\rangle$
-- **Einstein Field Equations**: $G_{\\mu\\nu} = \\frac{8\\pi G}{c^4} T_{\\mu\\nu}$`;
-    const expected = `- **Schrödinger Equation**: $$i\\hbar\\frac{\\partial}{\\partial t}|\\psi\\rangle = \\hat{H}|\\psi\\rangle$$
-- **Einstein Field Equations**: $$G_{\\mu\\nu} = \\frac{8\\pi G}{c^4} T_{\\mu\\nu}$$`;
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles financial calculations with currency', () => {
-    const content = `- **Simple Interest**: $A = P + Prt = $1,000 + ($1,000)(0.05)(2) = $1,100$
-- **ROI**: $\\text{ROI} = \\frac{$1,200 - $1,000}{$1,000} \\times 100\\% = 20\\%$`;
-    const expected = `- **Simple Interest**: $$A = P + Prt = \\$1,000 + (\\$1,000)(0.05)(2) = \\$1,100$$
-- **ROI**: $$\\text{ROI} = \\frac{\\$1,200 - \\$1,000}{\\$1,000} \\times 100\\% = 20\\%$$`;
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('does not convert partial or malformed expressions', () => {
-    const content = 'A single $ sign should not be converted';
-    const expected = 'A single $ sign should not be converted';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles nested parentheses in LaTeX', () => {
-    const content =
-      'Matrix determinant: $\\det(A) = \\sum_{\\sigma \\in S_n} \\text{sgn}(\\sigma) \\prod_{i=1}^n a_{i,\\sigma(i)}$';
-    const expected =
-      'Matrix determinant: $$\\det(A) = \\sum_{\\sigma \\in S_n} \\text{sgn}(\\sigma) \\prod_{i=1}^n a_{i,\\sigma(i)}$$';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('preserves spacing in equations', () => {
-    const content = 'Equation: $f(x) = 2x + 3$ where x is a variable.';
-    const expected = 'Equation: $$f(x) = 2x + 3$$ where x is a variable.';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles LaTeX with newlines inside should not be converted', () => {
-    const content = `This has $x
-y$ which spans lines`;
-    const expected = `This has $x
-y$ which spans lines`;
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles multiple dollar signs in text', () => {
-    const content = 'Price $100 then equation $x + y = z$ then another price $50';
-    const expected = 'Price \\$100 then equation $$x + y = z$$ then another price \\$50';
-    expect(preprocessLaTeX(content)).toBe(expected);
+import { createElement } from 'react';
+import ReactMarkdown from 'react-markdown';
+import { render } from '@testing-library/react';
+import { math } from 'micromark-extension-math';
+import { mathFromMarkdown } from 'mdast-util-math';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import type { Options as ReactMarkdownOptions } from 'react-markdown';
+import {
+  getRemarkPlugins,
+  getRehypePlugins,
+} from '~/components/Chat/Messages/Content/markdownConfig';
+import { singleDollarMath } from './latex';
+
+type SpecNode = {
+  type: string;
+  value?: string;
+  children?: SpecNode[];
+};
+
+/**
+ * Mirrors the production parser: `micromark-extension-math` resolves to
+ * `micromark-extension-llm-math` (vite alias in the app, moduleNameMapper here), with
+ * single-dollar spans handled exclusively by the `singleDollarMath` construct.
+ */
+const parse = (content: string): SpecNode =>
+  fromMarkdown(content, {
+    extensions: [math({ singleDollarTextMath: false }), singleDollarMath],
+    mdastExtensions: [mathFromMarkdown()],
+  }) as SpecNode;
+
+const collect = (node: SpecNode, type: string, values: string[] = []): string[] => {
+  if (node.type === type && node.value !== undefined) {
+    values.push(node.value);
+  }
+  for (const child of node.children ?? []) {
+    collect(child, type, values);
+  }
+  return values;
+};
+
+const hasType = (node: SpecNode, type: string): boolean => {
+  if (node.type === type) {
+    return true;
+  }
+  return (node.children ?? []).some((child) => hasType(child, type));
+};
+
+const inlineMath = (content: string): string[] => collect(parse(content), 'inlineMath');
+const flowMath = (content: string): string[] => collect(parse(content), 'math');
+const textOf = (content: string): string => collect(parse(content), 'text').join('');
+
+describe('singleDollarMath', () => {
+  describe('currency stays literal', () => {
+    test('Treasury buyback report (production bug)', () => {
+      const content =
+        'The U.S. Treasury said it would at least double long-dated bond buybacks, from $2bn to at least $4bn per operation starting Sept 9.';
+      expect(inlineMath(content)).toEqual([]);
+      expect(textOf(content)).toContain('from $2bn to at least $4bn per operation');
+    });
+
+    test('plain amounts', () => {
+      expect(inlineMath('Price is $50 and $100')).toEqual([]);
+      expect(inlineMath('$50 is $20 + $30')).toEqual([]);
+      expect(inlineMath('The price is $1,000,000 for this item.')).toEqual([]);
+      expect(inlineMath('Total: $29.50 plus tax')).toEqual([]);
+    });
+
+    test('abbreviated amounts', () => {
+      expect(inlineMath('Revenue: $5M to $10M, funding: $1.5B, price: $5K')).toEqual([]);
+      expect(inlineMath('$250k is 25% of $1M')).toEqual([]);
+      expect(inlineMath('More than $1bn in leveraged shorts, over $3bn total')).toEqual([]);
+    });
+
+    test('long decimals and large numbers', () => {
+      expect(inlineMath('You can win $1000000 or even $9999999.99!')).toEqual([]);
+      expect(inlineMath('Bitcoin: $0.00001234, Gas: $3.999, Rate: $1.234567890')).toEqual([]);
+      expect(
+        inlineMath('The total is $1157.90 (existing) + $500 (new investment) = $1657.90.'),
+      ).toEqual([]);
+    });
+
+    test('ranges with a punctuation dash reject on the trailing digit', () => {
+      expect(inlineMath('a $100-$200 range')).toEqual([]);
+      expect(inlineMath('a $100–$200 range')).toEqual([]);
+      expect(inlineMath('in the $10k-$20k band')).toEqual([]);
+    });
+
+    test('sums across a whole line', () => {
+      expect(inlineMath('- **Total Savings**: $500 + $200 + $150 = $850')).toEqual([]);
+    });
+
+    test('suffixed European style amounts', () => {
+      expect(inlineMath('Cela coûte 100$ et 200$ en Europe')).toEqual([]);
+    });
+
+    test('lone and trailing dollar signs', () => {
+      expect(inlineMath('A single $ sign should not be converted')).toEqual([]);
+      expect(inlineMath('The price hit $79,455 on')).toEqual([]);
+    });
+
+    test('amounts on separate lines of one paragraph', () => {
+      expect(inlineMath('Currency $100 and\nthen $200 later')).toEqual([]);
+    });
+  });
+
+  describe('single-dollar math parses', () => {
+    test('basic expressions', () => {
+      expect(inlineMath('Inline math: $x^2 + y^2 = z^2$')).toEqual(['x^2 + y^2 = z^2']);
+      expect(inlineMath('Equation: $f(x) = 2x + 3$ where x is a variable.')).toEqual([
+        'f(x) = 2x + 3',
+      ]);
+      expect(inlineMath('First $a + b = c$ and second $x^2 + y^2 = z^2$')).toEqual([
+        'a + b = c',
+        'x^2 + y^2 = z^2',
+      ]);
+    });
+
+    test('digit-led expressions are still math', () => {
+      expect(
+        inlineMath('- **Goldbach Conjecture**: $2n = p + q$ (every even integer > 2)'),
+      ).toEqual(['2n = p + q']);
+      expect(inlineMath('the answer is $3$.')).toEqual(['3']);
+      expect(inlineMath('an eigenvalue of $-1$ is expected')).toEqual(['-1']);
+    });
+
+    test('letters may follow the closer (ordinals)', () => {
+      expect(inlineMath('the $n$th term')).toEqual(['n']);
+    });
+
+    test('trailing punctuation after the closer', () => {
+      expect(inlineMath('The set is defined as $\\{x | x > 0\\}$.')).toEqual(['\\{x | x > 0\\}']);
+    });
+
+    test('physics expressions', () => {
+      const content = [
+        '- **Schrödinger Equation**: $i\\hbar\\frac{\\partial}{\\partial t}|\\psi\\rangle = \\hat{H}|\\psi\\rangle$',
+        '- **Einstein Field Equations**: $G_{\\mu\\nu} = \\frac{8\\pi G}{c^4} T_{\\mu\\nu}$',
+      ].join('\n');
+      expect(inlineMath(content)).toEqual([
+        'i\\hbar\\frac{\\partial}{\\partial t}|\\psi\\rangle = \\hat{H}|\\psi\\rangle',
+        'G_{\\mu\\nu} = \\frac{8\\pi G}{c^4} T_{\\mu\\nu}',
+      ]);
+    });
+
+    test('nested braces and subscripted products', () => {
+      expect(
+        inlineMath('Totient: $\\phi(n) = n \\prod_{p|n} \\left(1 - \\frac{1}{p}\\right)$'),
+      ).toEqual(['\\phi(n) = n \\prod_{p|n} \\left(1 - \\frac{1}{p}\\right)']);
+    });
+
+    test('escaped dollars stay inside the span', () => {
+      expect(inlineMath('Calculate $\\text{Total} = \\$500 + \\$200$')).toEqual([
+        '\\text{Total} = \\$500 + \\$200',
+      ]);
+      expect(inlineMath('The formula $f(x) = \\$2x$ represents cost')).toEqual(['f(x) = \\$2x']);
+    });
+
+    test('math and prices coexist', () => {
+      expect(inlineMath('Formula $x^2$ costs $25')).toEqual(['x^2']);
+      expect(inlineMath('LaTeX $x^2$ and price $50')).toEqual(['x^2']);
+      expect(inlineMath('Price $100 then equation $x + y = z$ then another price $50')).toEqual([
+        'x + y = z',
+      ]);
+    });
+
+    test('markdown characters inside math never form emphasis', () => {
+      const content = 'terms $a_1 + b_2$ and $c_{i}^{*}$ here';
+      expect(inlineMath(content)).toEqual(['a_1 + b_2', 'c_{i}^{*}']);
+      expect(hasType(parse(content), 'emphasis')).toBe(false);
+    });
+
+    test('mhchem passes through unmangled', () => {
+      expect(inlineMath('$\\ce{H2O}$ and $\\pu{123 J}$')).toEqual(['\\ce{H2O}', '\\pu{123 J}']);
+    });
+  });
+
+  describe('structural protection', () => {
+    test('inline code is untouchable', () => {
+      const content = 'Outside $x^2$ and inside code: `$100`';
+      expect(inlineMath(content)).toEqual(['x^2']);
+      expect(collect(parse(content), 'inlineCode')).toEqual(['$100']);
+    });
+
+    test('a span never swallows an inline code marker', () => {
+      const content = 'The error "invalid $lookup namespace" occurs when using `$lookup` operator';
+      expect(inlineMath(content)).toEqual([]);
+      expect(collect(parse(content), 'inlineCode')).toEqual(['$lookup']);
+    });
+
+    test('math and inline code coexist', () => {
+      const content = 'Use $x + y$ in math but `$lookup` in code';
+      expect(inlineMath(content)).toEqual(['x + y']);
+      expect(collect(parse(content), 'inlineCode')).toEqual(['$lookup']);
+    });
+
+    test('fenced code is untouchable', () => {
+      const content = '```\n$100\n$variable\n```\n\nOutside $x^2$';
+      expect(inlineMath(content)).toEqual(['x^2']);
+      expect(collect(parse(content), 'code')).toEqual(['$100\n$variable']);
+    });
+  });
+
+  describe('escapes and line boundaries', () => {
+    test('escaped dollars never open a span', () => {
+      expect(inlineMath('Already escaped \\$50 and \\$100')).toEqual([]);
+      expect(inlineMath('Escaped \\$x^2\\$ should not change')).toEqual([]);
+    });
+
+    test('single-dollar spans never cross lines', () => {
+      expect(inlineMath('This has $x\ny$ which spans lines')).toEqual([]);
+    });
+
+    test('a dangling escape abandons the span', () => {
+      expect(inlineMath('dangling $a\\')).toEqual([]);
+      expect(inlineMath('dangling $a\\\nnext line$')).toEqual([]);
+    });
+  });
+
+  describe('unambiguous delimiters are unaffected', () => {
+    test('double dollars, inline and flow', () => {
+      expect(inlineMath('This is valid: $$x^2 + y^2 = z^2$$')).toEqual(['x^2 + y^2 = z^2']);
+      expect(flowMath('$$\nE = mc^2\n$$')).toEqual(['E = mc^2']);
+    });
+
+    test('TeX brackets from the llm-math fork', () => {
+      expect(inlineMath('This is inline LaTeX: \\(x^2 + y^2 = z^2\\)')).toEqual([
+        'x^2 + y^2 = z^2',
+      ]);
+      const display = parse('\\[\nE = mc^2\n\\]');
+      expect([...collect(display, 'math'), ...collect(display, 'inlineMath')]).toEqual([
+        'E = mc^2',
+      ]);
+    });
+  });
+
+  describe('documented ambiguity limits', () => {
+    test('a trailing dollar-wrapped number still parses (Pandoc parity)', () => {
+      expect(inlineMath('Simple Interest: $A = P + Prt = $1,000 and = $1,100$')).toEqual(['1,100']);
+    });
+
+    test('unbalanced braces abandon the span', () => {
+      expect(inlineMath('weird $a}b$ y')).toEqual([]);
+      expect(inlineMath('open $a{b$ y')).toEqual([]);
+    });
   });
+});
 
-  test('handles complex LaTeX with currency in same expression', () => {
-    const content = 'Calculate $\\text{Total} = \\$500 + \\$200$';
-    const expected = 'Calculate $$\\text{Total} = \\$500 + \\$200$$';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
+describe('getRemarkPlugins LaTeX wiring', () => {
+  /** The config's unified@10 `PluggableList` and react-markdown's unified@11 plugin types are structurally compatible but nominally distinct, as at the production call sites. */
+  const renderMarkdown = (content: string, latexParsing: boolean) => {
+    const remarkPlugins = getRemarkPlugins(latexParsing) as ReactMarkdownOptions['remarkPlugins'];
+    return render(createElement(ReactMarkdown, { remarkPlugins }, content));
+  };
 
-  test('preserves already escaped dollars in LaTeX', () => {
-    const content = 'The formula $f(x) = \\$2x$ represents cost';
-    const expected = 'The formula $$f(x) = \\$2x$$ represents cost';
-    expect(preprocessLaTeX(content)).toBe(expected);
+  test('currency renders literally through the full plugin chain', () => {
+    const { container } = renderMarkdown('from $2bn to at least $4bn per operation', true);
+    expect(container.querySelector('.math-inline')).toBeNull();
+    expect(container.textContent).toContain('from $2bn to at least $4bn per operation');
   });
 
-  test('handles adjacent LaTeX and currency', () => {
-    const content = 'Formula $x^2$ costs $25';
-    const expected = 'Formula $$x^2$$ costs \\$25';
-    expect(preprocessLaTeX(content)).toBe(expected);
+  test('single-dollar math renders when enabled', () => {
+    const { container } = renderMarkdown('Equation $E=mc^2$ here', true);
+    const node = container.querySelector('.math-inline');
+    expect(node?.textContent).toBe('E=mc^2');
   });
 
-  test('handles LaTeX with special characters and currency', () => {
-    const content = 'Set $\\{x | x > \\$0\\}$ for positive prices';
-    const expected = 'Set $$\\{x | x > \\$0\\}$$ for positive prices';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
+  test('the toggle gates only single-dollar syntax', () => {
+    const single = renderMarkdown('Equation $E=mc^2$ here', false);
+    expect(single.container.querySelector('.math-inline')).toBeNull();
+    expect(single.container.textContent).toContain('$E=mc^2$');
 
-  test('does not convert when closing dollar is preceded by backtick', () => {
-    const content = 'The error "invalid $lookup namespace" occurs when using `$lookup` operator';
-    const expected = 'The error "invalid $lookup namespace" occurs when using `$lookup` operator';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
+    const double = renderMarkdown('Equation $$E=mc^2$$ here', false);
+    expect(double.container.querySelector('.math-inline')).not.toBeNull();
 
-  test('handles mixed backtick and non-backtick cases', () => {
-    const content = 'Use $x + y$ in math but `$lookup` in code';
-    const expected = 'Use $$x + y$$ in math but `$lookup` in code';
-    expect(preprocessLaTeX(content)).toBe(expected);
+    const brackets = renderMarkdown('Equation \\(E=mc^2\\) here', false);
+    expect(brackets.container.querySelector('.math-inline')).not.toBeNull();
   });
 
-  test('escapes currency amounts without commas', () => {
+  test('currency alongside citation anchors stays literal', () => {
     const content =
-      'The total amount invested is $1157.90 (existing amount) + $500 (new investment) = $1657.90.';
-    const expected =
-      'The total amount invested is \\$1157.90 (existing amount) + \\$500 (new investment) = \\$1657.90.';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles large currency amounts', () => {
-    const content = 'You can win $1000000 or even $9999999.99!';
-    const expected = 'You can win \\$1000000 or even \\$9999999.99!';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('escapes currency with many decimal places', () => {
-    const content = 'Bitcoin: $0.00001234, Gas: $3.999, Rate: $1.234567890';
-    const expected = 'Bitcoin: \\$0.00001234, Gas: \\$3.999, Rate: \\$1.234567890';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('escapes abbreviated currency notation', () => {
-    const content = '$250k is 25% of $1M';
-    const expected = '\\$250k is 25% of \\$1M';
-    expect(preprocessLaTeX(content)).toBe(expected);
-  });
-
-  test('handles various abbreviated currency formats', () => {
-    const content = 'Revenue: $5M to $10M, funding: $1.5B, price: $5K';
-    const expected = 'Revenue: \\$5M to \\$10M, funding: \\$1.5B, price: \\$5K';
-    expect(preprocessLaTeX(content)).toBe(expected);
+      'The U.S. Treasury said it would at least double long-dated bond buybacks, from $2bn to at least $4bn per operation starting Sept 9. turn0search4 That pushed long-end yields down.';
+    const { container } = renderMarkdown(content, true);
+    expect(container.querySelector('.math-inline')).toBeNull();
+    expect(container.textContent).toContain('from $2bn to at least $4bn per operation');
+  });
+
+  test('KaTeX renders the parsed spans without errors', () => {
+    const rehypePlugins = getRehypePlugins() as ReactMarkdownOptions['rehypePlugins'];
+    const remarkPlugins = getRemarkPlugins(true) as ReactMarkdownOptions['remarkPlugins'];
+    const { container } = render(
+      createElement(
+        ReactMarkdown,
+        { remarkPlugins, rehypePlugins },
+        'Water is $\\ce{H2O}$ where $E=mc^2$ costs $2bn to at least $4bn.',
+      ),
+    );
+    expect(container.querySelectorAll('.katex')).toHaveLength(2);
+    expect(container.querySelector('.katex-error')).toBeNull();
+    expect(container.textContent).toContain('costs $2bn to at least $4bn.');
+  });
+
+  test('currency and approx-tildes inside GFM table cells stay literal', () => {
+    const content = [
+      '| Date | Level | What happened |',
+      '|---|---|---|',
+      '| Aug 19 | ~$64,500 open | Treasury buyback news hits after hours turn0search4 |',
+      '| Aug 21 | $77,300, peak $79,455 | White House Clarity Act push |',
+    ].join('\n');
+    const { container } = renderMarkdown(content, true);
+    expect(container.querySelector('.math-inline')).toBeNull();
+    expect(container.textContent).toContain('$64,500 open');
+    expect(container.textContent).toContain('$77,300, peak $79,455');
   });
 });
diff --git a/client/src/utils/latex.ts b/client/src/utils/latex.ts
index 4467c2a5e35..c296a20c950 100644
--- a/client/src/utils/latex.ts
+++ b/client/src/utils/latex.ts
@@ -1,152 +1,148 @@
-// Pre-compile all regular expressions for better performance
-const MHCHEM_CE_REGEX = /\$\\ce\{/g;
-const MHCHEM_PU_REGEX = /\$\\pu\{/g;
-const MHCHEM_CE_ESCAPED_REGEX = /\$\\\\ce\{[^}]*\}\$/g;
-const MHCHEM_PU_ESCAPED_REGEX = /\$\\\\pu\{[^}]*\}\$/g;
-const CURRENCY_REGEX =
-  /(?<![\\$])\$(?!\$)(?=\d+(?:,\d{3})*(?:\.\d+)?(?:[KMBkmb])?(?:\s|$|[^a-zA-Z\d]))/g;
-const SINGLE_DOLLAR_REGEX = /(?<!\\)\$(?!\$)((?:[^$\n]|\\[$])+?)(?<!\\)(?<!`)\$(?!\$)/g;
-
-/**
- * Escapes mhchem package notation in LaTeX by converting single dollar delimiters to double dollars
- * and escaping backslashes in mhchem commands.
- *
- * @param text - The input text containing potential mhchem notation
- * @returns The processed text with properly escaped mhchem notation
- */
-function escapeMhchem(text: string): string {
-  // First escape the backslashes in mhchem commands
-  let result = text.replace(MHCHEM_CE_REGEX, '$\\\\ce{');
-  result = result.replace(MHCHEM_PU_REGEX, '$\\\\pu{');
-
-  // Then convert single dollar mhchem to double dollar
-  result = result.replace(MHCHEM_CE_ESCAPED_REGEX, (match) => `$${match}$`);
-  result = result.replace(MHCHEM_PU_ESCAPED_REGEX, (match) => `$${match}$`);
-
-  return result;
+import { codes, types } from 'micromark-util-symbol';
+import { asciiDigit, markdownLineEnding, markdownSpace } from 'micromark-util-character';
+import type {
+  Code,
+  Construct,
+  Effects,
+  Extension,
+  State,
+  TokenizeContext,
+} from 'micromark-util-types';
+import type { Plugin } from 'unified';
+import type { Root } from 'mdast';
+
+interface ParserData {
+  micromarkExtensions?: Extension[];
 }
 
 /**
- * Efficiently finds all code block regions in the content
- * @param content The content to analyze
- * @returns Array of code block regions [start, end]
+ * Single-dollar inline math is re-enabled here as a micromark construct instead of the
+ * string preprocessing it replaces, because `$...$` is ambiguous with prices ("from $2bn
+ * to at least $4bn") and only the tokenizer can decide a span without rewriting the
+ * message: code spans, fences, and autolinks are structurally excluded, and a rejected
+ * span stays byte-identical text. `remark-math` keeps running with
+ * `singleDollarTextMath: false`; this construct is the sole single-dollar path.
+ *
+ * A `$...$` span becomes math only when all of Pandoc's boundary rules hold:
+ * - the opening `$` is immediately followed by a non-space character;
+ * - the closing `$` is immediately preceded by a non-space character and not immediately
+ *   followed by a digit (rejects ranges like "$100-$200");
+ * - the span stays on one line, contains no backtick, treats `\`-pairs as opaque
+ *   (`\$` stays inside the span), and closes with balanced braces.
+ *
+ * A failed close abandons the whole attempt (`nok`) instead of scanning further, so the
+ * next `$` in "Price is $50 and $100" can never silently extend a span; micromark then
+ * retries the construct at that `$` on its own merits.
  */
-function findCodeBlockRegions(content: string): Array<[number, number]> {
-  const regions: Array<[number, number]> = [];
-  let inlineStart = -1;
-  let multilineStart = -1;
-
-  for (let i = 0; i < content.length; i++) {
-    const char = content[i];
+function tokenizeMathSpan(this: TokenizeContext, effects: Effects, ok: State, nok: State): State {
+  let previousCode: Code = null;
+  let braceDepth = 0;
+
+  function start(code: Code): State | undefined {
+    effects.enter('mathText');
+    effects.enter('mathTextSequence');
+    effects.consume(code);
+    effects.exit('mathTextSequence');
+    return open;
+  }
 
-    // Check for multiline code blocks
+  function open(code: Code): State | undefined {
     if (
-      char === '`' &&
-      i + 2 < content.length &&
-      content[i + 1] === '`' &&
-      content[i + 2] === '`'
+      code === codes.eof ||
+      code === codes.dollarSign ||
+      code === codes.graveAccent ||
+      markdownSpace(code) ||
+      markdownLineEnding(code)
     ) {
-      if (multilineStart === -1) {
-        multilineStart = i;
-        i += 2; // Skip the next two backticks
-      } else {
-        regions.push([multilineStart, i + 2]);
-        multilineStart = -1;
-        i += 2;
+      return nok(code);
+    }
+    effects.enter('mathTextData');
+    return content(code);
+  }
+
+  function content(code: Code): State | undefined {
+    if (code === codes.eof || code === codes.graveAccent || markdownLineEnding(code)) {
+      return nok(code);
+    }
+    if (code === codes.dollarSign) {
+      if (markdownSpace(previousCode) || braceDepth !== 0) {
+        return nok(code);
       }
+      effects.exit('mathTextData');
+      effects.enter('mathTextSequence');
+      effects.consume(code);
+      return close;
+    }
+    if (code === codes.backslash) {
+      effects.consume(code);
+      return escape;
+    }
+    if (code === codes.leftCurlyBrace) {
+      braceDepth++;
     }
-    // Check for inline code blocks (only if not in multiline)
-    else if (char === '`' && multilineStart === -1) {
-      if (inlineStart === -1) {
-        inlineStart = i;
-      } else {
-        regions.push([inlineStart, i]);
-        inlineStart = -1;
+    if (code === codes.rightCurlyBrace) {
+      if (braceDepth === 0) {
+        return nok(code);
       }
+      braceDepth--;
     }
+    previousCode = code;
+    effects.consume(code);
+    return content;
   }
 
-  return regions;
-}
-
-/**
- * Checks if a position is inside any code block region using binary search
- * @param position The position to check
- * @param codeRegions Array of code block regions
- * @returns True if position is inside a code block
- */
-function isInCodeBlock(position: number, codeRegions: Array<[number, number]>): boolean {
-  let left = 0;
-  let right = codeRegions.length - 1;
-
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    const [start, end] = codeRegions[mid];
-
-    if (position >= start && position <= end) {
-      return true;
-    } else if (position < start) {
-      right = mid - 1;
-    } else {
-      left = mid + 1;
+  function escape(code: Code): State | undefined {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      return nok(code);
     }
+    previousCode = code;
+    effects.consume(code);
+    return content;
   }
 
-  return false;
-}
-
-/**
- * Preprocesses LaTeX content by escaping currency indicators and converting single dollar math delimiters.
- * Optimized for high-frequency execution.
- * @param content The input string containing LaTeX expressions.
- * @returns The processed string with escaped currency indicators and converted math delimiters.
- */
-export function preprocessLaTeX(content: string): string {
-  // Early return for most common case
-  if (!content.includes('$')) return content;
-
-  // Process mhchem first (usually rare, so check if needed)
-  let processed = content;
-  if (content.includes('\\ce{') || content.includes('\\pu{')) {
-    processed = escapeMhchem(content);
-  }
-
-  // Find all code block regions once
-  const codeRegions = findCodeBlockRegions(processed);
-
-  // First pass: escape currency dollar signs
-  const parts: string[] = [];
-  let lastIndex = 0;
-
-  // Reset regex for reuse
-  CURRENCY_REGEX.lastIndex = 0;
-
-  let match: RegExpExecArray | null;
-  while ((match = CURRENCY_REGEX.exec(processed)) !== null) {
-    if (!isInCodeBlock(match.index, codeRegions)) {
-      parts.push(processed.substring(lastIndex, match.index));
-      parts.push('\\$');
-      lastIndex = match.index + 1;
+  function close(code: Code): State | undefined {
+    if (code === codes.dollarSign || asciiDigit(code)) {
+      return nok(code);
     }
+    effects.exit('mathTextSequence');
+    effects.exit('mathText');
+    return ok(code);
   }
-  parts.push(processed.substring(lastIndex));
-  processed = parts.join('');
 
-  // Second pass: convert single dollar delimiters to double dollars
-  const result: string[] = [];
-  lastIndex = 0;
+  return start;
+}
 
-  // Reset regex for reuse
-  SINGLE_DOLLAR_REGEX.lastIndex = 0;
+/** Mirrors `micromark-extension-math`: a `$` opener is valid unless it follows an unescaped `$`. */
+function previous(this: TokenizeContext, code: Code): boolean {
+  return (
+    code !== codes.dollarSign ||
+    this.events[this.events.length - 1][1].type === types.characterEscape
+  );
+}
 
-  while ((match = SINGLE_DOLLAR_REGEX.exec(processed)) !== null) {
-    if (!isInCodeBlock(match.index, codeRegions)) {
-      result.push(processed.substring(lastIndex, match.index));
-      result.push(`$$${match[1]}$$`);
-      lastIndex = match.index + match[0].length;
-    }
-  }
-  result.push(processed.substring(lastIndex));
+const mathSpan: Construct = {
+  name: 'mathSpanSingleDollar',
+  tokenize: tokenizeMathSpan,
+  previous,
+};
 
-  return result.join('');
-}
+/**
+ * micromark syntax extension adding currency-safe single-dollar inline math. It emits the
+ * same `mathText`/`mathTextData` tokens as `micromark-extension-math`, so `remark-math`'s
+ * `mathFromMarkdown` handlers turn its spans into regular `inlineMath` nodes. Registration
+ * order relative to `remark-math` is immaterial: this construct rejects `$$` openers and
+ * `remark-math` (with `singleDollarTextMath: false`) rejects single `$` openers.
+ */
+export const singleDollarMath: Extension = {
+  text: { [codes.dollarSign]: mathSpan },
+};
+
+/**
+ * remark plugin enabling {@link singleDollarMath}. Must run alongside `remark-math`, which
+ * registers the mdast handlers for the tokens this extension emits.
+ */
+export const remarkSingleDollarMath: Plugin<[], Root> = function remarkSingleDollarMath() {
+  const data = this.data() as ParserData;
+  const extensions = (data.micromarkExtensions ??= []);
+  extensions.push(singleDollarMath);
+};
diff --git a/client/src/utils/steer.ts b/client/src/utils/steer.ts
index d6c4ed5c43d..45358323584 100644
--- a/client/src/utils/steer.ts
+++ b/client/src/utils/steer.ts
@@ -56,6 +56,89 @@ export function collectAppliedSteerIds(values: unknown[] | undefined): string[]
   return [...ids];
 }
 
+/** Ids of applied steer parts that carry NO quotes, same traversal as
+ * `collectAppliedSteerIds`. Paired with a quote-bearing local chip, such a
+ * part proves a pre-quotes server injected the words bare — the chip's
+ * excerpts must be re-staged before the settle removes their only copy. */
+export function collectQuotelessAppliedSteerIds(values: unknown[] | undefined): Set<string> {
+  if (!values) {
+    return new Set();
+  }
+  const ids = new Set<string>();
+  for (const value of values) {
+    if (value == null || typeof value !== 'object') {
+      continue;
+    }
+    const object = value as { content?: unknown };
+    const parts = Array.isArray(object.content) ? object.content : [value];
+    for (const part of parts) {
+      if (part == null || typeof part !== 'object') {
+        continue;
+      }
+      const candidate = part as {
+        type?: unknown;
+        steerId?: unknown;
+        clientSteerId?: unknown;
+        quotes?: unknown;
+      };
+      if (candidate.type !== ContentTypes.STEER) {
+        continue;
+      }
+      if (Array.isArray(candidate.quotes) && candidate.quotes.length > 0) {
+        continue;
+      }
+      if (typeof candidate.steerId === 'string') {
+        ids.add(candidate.steerId);
+      }
+      if (typeof candidate.clientSteerId === 'string') {
+        ids.add(candidate.clientSteerId);
+      }
+    }
+  }
+  return ids;
+}
+
+/** Max excerpts staged at once; mirrors the backend `QUOTE_MAX_COUNT` cap so
+ *  every displayed chip actually reaches the model on the next send. */
+export const MAX_QUOTE_COUNT = 10;
+
+/** Dedupe-appends re-staged excerpts onto the composer's pending-quote chips,
+ * returning `prev` untouched when nothing new lands (Recoil referential
+ * stability). The dedupe also makes the multiple restore triggers — ACK echo,
+ * applied event, reconnect settle — idempotent for the same excerpts. Capped
+ * at `MAX_QUOTE_COUNT` with the already-staged chips winning: a restored tail
+ * that cannot ride the next send is dropped explicitly rather than displayed
+ * as a chip the submission would silently discard. */
+export function mergeRestagedQuotes(prev: string[], quotes: string[]): string[] {
+  const room = MAX_QUOTE_COUNT - prev.length;
+  if (room <= 0) {
+    return prev;
+  }
+  const fresh = quotes.filter((quote) => !prev.includes(quote)).slice(0, room);
+  return fresh.length > 0 ? [...prev, ...fresh] : prev;
+}
+
+/** Excerpts to re-stage when applied steer parts settle their chips: the
+ * quotes carried by each chip whose applied part has none — proof a
+ * pre-quotes server injected the words bare, leaving the chip as the only
+ * copy of the user's excerpts. */
+export function collectDroppedSteerQuotes(
+  values: unknown[] | undefined,
+  chips: readonly Pick<TPendingSteer, 'steerId' | 'clientSteerId' | 'quotes'>[],
+): string[] {
+  const quoteless = collectQuotelessAppliedSteerIds(values);
+  if (quoteless.size === 0) {
+    return [];
+  }
+  return chips.flatMap((steer) =>
+    (steer.quotes?.length ?? 0) > 0 &&
+    (quoteless.has(steer.steerId) ||
+      (steer.clientSteerId != null && quoteless.has(steer.clientSteerId)))
+      ? (steer.quotes ?? [])
+      : [],
+  );
+}
+
 /**
  * Places an injected steer part at its absolute content index on the target
  * response message. The server reserved that slot (subsequent SDK events were
@@ -143,9 +226,11 @@ export function appendAppliedSteerIds(prev: string[], steerIds: string[]): strin
 
 export type SteerCarriedContext = { quotes?: string[]; manualSkills?: string[] };
 
-/** Quotes/skill picks are client-only (a steer never sends them to the
- *  server); chip mints, reseeds, and queued conversions carry them from the
- *  local source so the context survives a steer that never injects. */
+/** Quotes ride the steer POST (the server merges them into the injected
+ *  turn) but chips, reseeds, and queued conversions still carry them locally
+ *  so a steer that never injects restores with its excerpts intact. Skill
+ *  picks are client-only — they configure a NEW turn's run, so only the
+ *  restore paths carry them. */
 export function carriedSteerContext(source?: SteerCarriedContext): SteerCarriedContext {
   const quotes = source?.quotes;
   const manualSkills = source?.manualSkills;
diff --git a/package-lock.json b/package-lock.json
index 1d14c5da1c2..0b0a01e35dc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -986,6 +986,8 @@
         "micromark-extension-gfm": "^3.0.0",
         "micromark-extension-llm-math": "^3.1.0",
         "micromark-extension-math": "^3.1.0",
+        "micromark-util-character": "^2.1.0",
+        "micromark-util-symbol": "^2.0.0",
         "monaco-editor": "^0.56.0",
         "qrcode.react": "^4.2.0",
         "rc-input-number": "^7.4.2",
@@ -1054,6 +1056,7 @@
         "jest-environment-jsdom": "^30.2.0",
         "jest-file-loader": "^1.0.3",
         "jest-junit": "^17.0.0",
+        "micromark-util-types": "^2.0.0",
         "postcss": "^8.5.18",
         "postcss-preset-env": "^11.2.0",
         "tailwindcss": "^3.4.1",
diff --git a/packages/api/src/agents/steering/__tests__/media.spec.ts b/packages/api/src/agents/steering/__tests__/media.spec.ts
index 6c5e15c6ab7..09515181562 100644
--- a/packages/api/src/agents/steering/__tests__/media.spec.ts
+++ b/packages/api/src/agents/steering/__tests__/media.spec.ts
@@ -1,7 +1,7 @@
 import type { IMongoFile } from '@librechat/data-schemas';
 import type { SteerFileFetcher } from '../request';
 import type { SteerMediaClient } from '../media';
-import { buildSteerMedia, stampSteerPartMedia } from '../media';
+import { buildSteerMedia, collectSteerStampTargets, stampSteerPartMedia } from '../media';
 
 jest.spyOn(console, 'log').mockImplementation();
 
@@ -180,6 +180,23 @@ describe('buildSteerMedia', () => {
       {},
     );
   });
+
+  it('merges quoted excerpts into the encoded text part', async () => {
+    const getFiles: SteerFileFetcher = jest.fn(async () => [imageDoc]);
+    const client = createClient({ image_urls: [imagePart] });
+
+    const result = await buildSteerMedia({
+      client,
+      user,
+      item: { ...steerItem([{ file_id: 'f1' }], 'what about this?'), quotes: ['the excerpt'] },
+      getFiles,
+    });
+
+    expect(result?.content).toEqual([
+      { type: 'text', text: '> the excerpt\n\nwhat about this?' },
+      imagePart,
+    ]);
+  });
 });
 
 describe('stampSteerPartMedia', () => {
@@ -268,4 +285,148 @@ describe('stampSteerPartMedia', () => {
     expect((message.content as unknown[])[0]).toBe(steerPart);
     expect(steerPart).not.toHaveProperty('media');
   });
+
+  it('stamps merged text media for a quote-bearing part without files', async () => {
+    const getFiles: SteerFileFetcher = jest.fn(async () => []);
+    const client = createClient();
+    const steerPart = {
+      type: 'steer',
+      steer: 'and this part?',
+      steerId: 's3',
+      quotes: ['first excerpt', 'second excerpt'],
+    };
+    const message = { messageId: 'assistant-q', role: 'assistant', content: [steerPart] };
+
+    const stamped = await stampSteerPartMedia({ client, user, payload: [message], getFiles });
+
+    expect(getFiles).not.toHaveBeenCalled();
+    expect(client.processAttachments).not.toHaveBeenCalled();
+    const merged = '> first excerpt\n\n> second excerpt\n\nand this part?';
+    expect((message.content as Array<Record<string, unknown>>)[0].media).toEqual([
+      { type: 'text', text: merged },
+    ]);
+    expect(steerPart).not.toHaveProperty('media');
+    expect(stamped).toEqual([
+      {
+        index: 0,
+        sourceMessageId: 'assistant-q',
+        fileIds: [],
+        media: [{ type: 'text', text: merged }],
+        steerText: 'and this part?',
+      },
+    ]);
+  });
+
+  it('merges quotes into the encoded text part of a files-carrying steer', async () => {
+    const getFiles: SteerFileFetcher = jest.fn(async () => [imageDoc]);
+    const client = createClient({ image_urls: [imagePart] });
+    const steerPart = {
+      type: 'steer',
+      steer: 'see attachment',
+      steerId: 's4',
+      files: [{ file_id: 'f1' }],
+      quotes: ['quoted line'],
+    };
+    const message = { role: 'assistant', content: [steerPart] };
+
+    const stamped = await stampSteerPartMedia({ client, user, payload: [message], getFiles });
+
+    expect(stamped[0].media).toEqual([
+      { type: 'text', text: '> quoted line\n\nsee attachment' },
+      imagePart,
+    ]);
+    expect(stamped[0].steerText).toBe('see attachment');
+  });
+
+  it('still stamps merged text when a quote-bearing part loses its files', async () => {
+    const getFiles: SteerFileFetcher = jest.fn(async () => []);
+    const steerPart = {
+      type: 'steer',
+      steer: 'orphaned but quoted',
+      steerId: 's5',
+      files: [{ file_id: 'gone' }],
+      quotes: ['the reference'],
+    };
+    const message = { role: 'assistant', content: [steerPart] };
+
+    const stamped = await stampSteerPartMedia({
+      client: createClient(),
+      user,
+      payload: [message],
+      getFiles,
+    });
+
+    expect(stamped[0].fileIds).toEqual([]);
+    expect(stamped[0].media).toEqual([
+      { type: 'text', text: '> the reference\n\norphaned but quoted' },
+    ]);
+  });
+
+  it('collects stamp targets synchronously so steer-free payloads skip the await', () => {
+    const plain = [
+      { role: 'user', content: 'hi' },
+      { role: 'assistant', content: [{ type: 'text', text: 'answer' }] },
+    ];
+    expect(collectSteerStampTargets(plain, true)).toHaveLength(0);
+
+    const filesOnly = [
+      { role: 'assistant', content: [{ type: 'steer', steer: 's', files: [{ file_id: 'f1' }] }] },
+    ];
+    expect(collectSteerStampTargets(filesOnly, true)).toHaveLength(1);
+    expect(collectSteerStampTargets(filesOnly, false)).toHaveLength(0);
+
+    const quoted = [{ role: 'assistant', content: [{ type: 'steer', steer: 's', quotes: ['q'] }] }];
+    expect(collectSteerStampTargets(quoted, false)).toHaveLength(1);
+  });
+
+  it('consumes pre-collected targets without re-scanning the payload', async () => {
+    const getFiles: SteerFileFetcher = jest.fn(async () => []);
+    const steerPart = { type: 'steer', steer: 'quoted turn', steerId: 's8', quotes: ['kept'] };
+    const message = { role: 'assistant', content: [steerPart] };
+    const targets = collectSteerStampTargets([message], false);
+
+    const stamped = await stampSteerPartMedia({
+      client: createClient(),
+      user,
+      payload: [message],
+      targets,
+      getFiles,
+      resendFiles: false,
+    });
+
+    expect(stamped[0].media).toEqual([{ type: 'text', text: '> kept\n\nquoted turn' }]);
+  });
+
+  it('replays quotes without encoding files when resendFiles is off', async () => {
+    const getFiles: SteerFileFetcher = jest.fn(async () => [imageDoc]);
+    const client = createClient({ image_urls: [imagePart] });
+    const quotedPart = {
+      type: 'steer',
+      steer: 'quoted turn',
+      steerId: 's6',
+      files: [{ file_id: 'f1' }],
+      quotes: ['kept excerpt'],
+    };
+    const filesOnlyPart = {
+      type: 'steer',
+      steer: 'files only',
+      steerId: 's7',
+      files: [{ file_id: 'f1' }],
+    };
+    const message = { role: 'assistant', content: [quotedPart, filesOnlyPart] };
+
+    const stamped = await stampSteerPartMedia({
+      client,
+      user,
+      payload: [message],
+      getFiles,
+      resendFiles: false,
+    });
+
+    expect(getFiles).not.toHaveBeenCalled();
+    expect(client.processAttachments).not.toHaveBeenCalled();
+    expect(stamped).toHaveLength(1);
+    expect(stamped[0].media).toEqual([{ type: 'text', text: '> kept excerpt\n\nquoted turn' }]);
+    expect((message.content as Array<Record<string, unknown>>)[1]).toBe(filesOnlyPart);
+  });
 });
diff --git a/packages/api/src/agents/steering/__tests__/request.spec.ts b/packages/api/src/agents/steering/__tests__/request.spec.ts
index 646e521ce6a..d3e694e11ed 100644
--- a/packages/api/src/agents/steering/__tests__/request.spec.ts
+++ b/packages/api/src/agents/steering/__tests__/request.spec.ts
@@ -296,6 +296,89 @@ describe('handleSteerRequest (real in-memory job manager)', () => {
     ]);
   });
 
+  it('normalizes quoted excerpts into the queue item like the chat route', async () => {
+    const streamId = 'steer-req-quotes';
+    await GenerationJobManager.createJob(streamId, user.id, undefined, {
+      initialMetadata: { steerQuotesCapable: true },
+    });
+
+    const result = await handleSteerRequest(user, {
+      conversationId: streamId,
+      text: 'about the selection',
+      quotes: ['  kept excerpt  ', '', 42, 'second'],
+    });
+
+    expect(result.status).toBe(202);
+    expect(result.body.quotesAccepted).toBe(true);
+    const queued = await GenerationJobManager.steering.peek(streamId);
+    expect(queued[0].quotes).toEqual(['kept excerpt', 'second']);
+  });
+
+  it('atomically strips quotes when a legacy HITL handover races the admission', async () => {
+    // A resume keeps createdAt, so the enqueue fence cannot see the handover.
+    // A LEGACY resumer rewrites providerExecutionId without knowing the quote
+    // marker, which invalidates the previous owner's assertion; the enqueue
+    // transaction evaluates that equality against the LIVE job — after the
+    // admission's own capability read already said capable — and the returned
+    // persisted item keeps the echo honest.
+    const streamId = 'steer-req-quotes-downgrade';
+    await GenerationJobManager.createJob(streamId, user.id, undefined, {
+      initialMetadata: { steerQuotesCapable: true },
+    });
+
+    const result = await handleSteerRequest(
+      user,
+      { conversationId: streamId, text: 'about the selection', quotes: ['the excerpt'] },
+      {
+        checkAgentAccess: async () => {
+          const stored = await GenerationJobManager.getJobStore().getJob(streamId);
+          (stored as { providerExecutionId?: string }).providerExecutionId = 'legacy-resume-exec';
+          return true;
+        },
+      },
+    );
+
+    expect(result.status).toBe(202);
+    expect(result.body).not.toHaveProperty('quotesAccepted');
+    const queued = await GenerationJobManager.steering.peek(streamId);
+    expect(queued[0]).not.toHaveProperty('quotes');
+  });
+
+  it('drops quotes without the echo when the generation owner cannot merge them', async () => {
+    // The job was created by a pre-quotes replica (no capability flag): an
+    // upgraded admission replica must not store quotes its owning drain would
+    // silently ignore — the missing echo makes the client re-stage them.
+    const streamId = 'steer-req-quotes-incapable-owner';
+    await GenerationJobManager.createJob(streamId, user.id);
+
+    const result = await handleSteerRequest(user, {
+      conversationId: streamId,
+      text: 'about the selection',
+      quotes: ['the excerpt'],
+    });
+
+    expect(result.status).toBe(202);
+    expect(result.body).not.toHaveProperty('quotesAccepted');
+    const queued = await GenerationJobManager.steering.peek(streamId);
+    expect(queued[0]).not.toHaveProperty('quotes');
+  });
+
+  it('omits quotes from the queue item when nothing usable was sent', async () => {
+    const streamId = 'steer-req-no-quotes';
+    await GenerationJobManager.createJob(streamId, user.id);
+
+    const result = await handleSteerRequest(user, {
+      conversationId: streamId,
+      text: 'plain steer',
+      quotes: 'not-an-array',
+    });
+
+    expect(result.status).toBe(202);
+    expect(result.body).not.toHaveProperty('quotesAccepted');
+    const queued = await GenerationJobManager.steering.peek(streamId);
+    expect(queued[0]).not.toHaveProperty('quotes');
+  });
+
   describe('injected getFiles (owner-scoped resolve at enqueue)', () => {
     const dbDoc = {
       file_id: 'f1',
@@ -805,6 +888,103 @@ describe('generation protocol bridge for steering mutations', () => {
     expect(publishUpdate).toHaveBeenCalledTimes(1);
   });
 
+  it('keeps receipt fingerprints quote-independent so legacy replicas can replay them', async () => {
+    // The 3-field hash is the one shape EVERY deployed version computes: a
+    // lost-ACK retry of a quoted steer routed through a pre-quotes replica
+    // must replay the receipt, not 409 accepted words as a conflict.
+    const streamId = 'steer-protocol-v2-legacy-replayable';
+    await GenerationJobManager.createJob(streamId, user.id, undefined, {
+      initialMetadata: { generationProtocolVersion: 2, steerQuotesCapable: true },
+    });
+    const base = { conversationId: streamId, text: 'identical words' };
+
+    await handleSteerRequest(
+      user,
+      { ...base, clientSteerId: 'client-quoted', quotes: ['the excerpt'] },
+      { generationProtocolVersion: 2 },
+    );
+    await handleSteerRequest(
+      user,
+      { ...base, clientSteerId: 'client-plain' },
+      { generationProtocolVersion: 2 },
+    );
+
+    const quoted = await GenerationJobManager.steering.getReceipt(streamId, 'client-quoted');
+    const plain = await GenerationJobManager.steering.getReceipt(streamId, 'client-plain');
+    expect(quoted?.fingerprint).toBe(plain?.fingerprint);
+    expect(typeof quoted?.requestedQuotesFingerprint).toBe('string');
+    expect(plain?.requestedQuotesFingerprint).toBeUndefined();
+  });
+
+  it('treats quotes as part of the idempotency identity', async () => {
+    const streamId = 'steer-protocol-v2-quote-fingerprint';
+    await GenerationJobManager.createJob(streamId, user.id, undefined, {
+      initialMetadata: { generationProtocolVersion: 2, steerQuotesCapable: true },
+    });
+    const requestBody = {
+      conversationId: streamId,
+      clientSteerId: 'client-v2-quoted',
+      text: 'about this excerpt',
+      quotes: ['the excerpt'],
+    };
+
+    const accepted = await handleSteerRequest(user, requestBody, {
+      generationProtocolVersion: 2,
+    });
+    const replayed = await handleSteerRequest(user, requestBody, {
+      generationProtocolVersion: 2,
+    });
+    const conflicting = await handleSteerRequest(
+      user,
+      { ...requestBody, quotes: ['a different excerpt'] },
+      { generationProtocolVersion: 2 },
+    );
+
+    expect(accepted.status).toBe(202);
+    expect(accepted.body.quotesAccepted).toBe(true);
+    expect(replayed.body).toMatchObject({
+      steerId: accepted.body.steerId,
+      replayed: true,
+      // Echoed from the durable item so a lost-ACK retry still learns the
+      // excerpts were attached to the accepted words.
+      quotesAccepted: true,
+    });
+    expect(conflicting.status).toBe(409);
+    expect(conflicting.body.code).toBe('STEER_IDEMPOTENCY_CONFLICT');
+  });
+
+  it('replays a legacy quote-less receipt for a quoted retry of the same words', async () => {
+    // Cross-version lost ACK: a pre-quotes replica accepted the words and its
+    // receipt hashes only text/files/preempt. The retry now carries quotes —
+    // it must replay that receipt (the words are already durable) and OMIT the
+    // quotesAccepted echo so the client re-stages the dropped excerpts.
+    const streamId = 'steer-protocol-v2-legacy-fingerprint';
+    await GenerationJobManager.createJob(streamId, user.id, undefined, {
+      initialMetadata: { generationProtocolVersion: 2 },
+    });
+    const requestBody = {
+      conversationId: streamId,
+      clientSteerId: 'client-v2-legacy-quoted',
+      text: 'same accepted words',
+    };
+    const receiptEnqueue = jest.spyOn(GenerationJobManager.steering, 'enqueueWithReceipt');
+
+    const accepted = await handleSteerRequest(user, requestBody, {
+      generationProtocolVersion: 2,
+    });
+    const quotedRetry = await handleSteerRequest(
+      user,
+      { ...requestBody, quotes: ['the excerpt'] },
+      { generationProtocolVersion: 2 },
+    );
+
+    expect(accepted.status).toBe(202);
+    expect(quotedRetry.status).toBe(202);
+    expect(quotedRetry.body).toMatchObject({ steerId: accepted.body.steerId, replayed: true });
+    expect(quotedRetry.body).not.toHaveProperty('quotesAccepted');
+    expect(receiptEnqueue).toHaveBeenCalledTimes(1);
+  });
+
   it('replays a v2 receipt after terminal cleanup deletes the accepting job', async () => {
     const streamId = 'steer-protocol-v2-replay-after-delete';
     const job = await GenerationJobManager.createJob(streamId, user.id, undefined, {
diff --git a/packages/api/src/agents/steering/__tests__/runtime.spec.ts b/packages/api/src/agents/steering/__tests__/runtime.spec.ts
index f35d2908f81..883a5dbc49b 100644
--- a/packages/api/src/agents/steering/__tests__/runtime.spec.ts
+++ b/packages/api/src/agents/steering/__tests__/runtime.spec.ts
@@ -6,10 +6,9 @@ import type {
 } from '@librechat/agents';
 import type { SteerQueueItem } from '~/stream/interfaces/IJobStore';
 
-/** Mirrors runtime.ts's local extension — the field predates the SDK pin bump. */
-type SteerDrainOutput = PostToolBatchHookOutput & {
-  injectedMessages?: Array<{ role: string; content: string; source: string }>;
-};
+/** The pinned SDK's hook output declares `injectedMessages` natively; a
+ *  narrower local re-declaration would no longer be assignable from it. */
+type SteerDrainOutput = PostToolBatchHookOutput;
 import { InMemoryEventTransport } from '~/stream/implementations/InMemoryEventTransport';
 import { InMemoryJobStore } from '~/stream/implementations/InMemoryJobStore';
 import { GenerationJobManager } from '~/stream/GenerationJobManager';
@@ -204,6 +203,54 @@ describe('createSteerDrainHook', () => {
     ]);
   });
 
+  it('merges quoted excerpts into text-only injections (media path merges its own)', async () => {
+    const streamId = `drain-quotes-${Date.now()}`;
+    const job = await GenerationJobManager.createJob(streamId, 'user-1', undefined, {
+      initialMetadata: { steerQuotesCapable: true },
+    });
+    await GenerationJobManager.steering.enqueue(streamId, {
+      ...buildSteer('s1', 'what does this mean?'),
+      quotes: ['selected passage'],
+    });
+
+    const hook = createSteerDrainHook({
+      streamId,
+      jobCreatedAt: job.createdAt,
+      applySteer: jest.fn(),
+    });
+
+    const output: SteerDrainOutput = await hook(batchInput(), abortSignal);
+    expect(output.injectedMessages).toEqual([
+      { role: 'user', content: '> selected passage\n\nwhat does this mean?', source: 'steer' },
+    ]);
+  });
+
+  it('keeps quotes in the injection when media encoding degrades to text', async () => {
+    const streamId = `drain-quotes-degrade-${Date.now()}`;
+    const job = await GenerationJobManager.createJob(streamId, 'user-1', undefined, {
+      initialMetadata: { steerQuotesCapable: true },
+    });
+    await GenerationJobManager.steering.enqueue(streamId, {
+      ...buildSteer('s1', 'and the doc?'),
+      files: [{ file_id: 'f1', type: 'image/png' }],
+      quotes: ['quoted context'],
+    });
+
+    const hook = createSteerDrainHook({
+      streamId,
+      jobCreatedAt: job.createdAt,
+      applySteer: jest.fn(),
+      buildMedia: jest.fn(async () => {
+        throw new Error('encode failed');
+      }),
+    });
+
+    const output: SteerDrainOutput = await hook(batchInput(), abortSignal);
+    expect(output.injectedMessages).toEqual([
+      { role: 'user', content: '> quoted context\n\nand the doc?', source: 'steer' },
+    ]);
+  });
+
   it('persists the steer part BEFORE media encoding (abort-safe ordering)', async () => {
     const streamId = `drain-apply-first-${Date.now()}`;
     const job = await GenerationJobManager.createJob(streamId, 'user-1');
diff --git a/packages/api/src/agents/steering/index.ts b/packages/api/src/agents/steering/index.ts
index 6487de5e57f..4f1eab09c19 100644
--- a/packages/api/src/agents/steering/index.ts
+++ b/packages/api/src/agents/steering/index.ts
@@ -21,8 +21,8 @@ export type {
   SteerFileFetcher,
   SteerRequestResult,
 } from './request';
-export { buildSteerMedia, stampSteerPartMedia } from './media';
-export type { SteerMediaClient, StampedSteerMedia } from './media';
+export { buildSteerMedia, collectSteerStampTargets, stampSteerPartMedia } from './media';
+export type { SteerMediaClient, SteerStampTarget, StampedSteerMedia } from './media';
 export { createSteerIndexOffsetHandlers } from './offset';
 export type { SteerOffsetState } from './offset';
 export { toSteerFileRef } from './refs';
diff --git a/packages/api/src/agents/steering/media.ts b/packages/api/src/agents/steering/media.ts
index 24c22ad0b5f..879a7ad2d1a 100644
--- a/packages/api/src/agents/steering/media.ts
+++ b/packages/api/src/agents/steering/media.ts
@@ -8,6 +8,7 @@ import type { SteerFileFetcher } from './request';
 import type { SteerMediaResult } from './runtime';
 import type { SteerRequestUser } from './refs';
 import { toSteerFileRef, collectFileIds, buildOwnerFilter } from './refs';
+import { getReferencedQuotes, mergeQuotedText } from '~/utils';
 import { prependFileContext } from '../client';
 
 /** The BaseClient encode surface the steer media pipeline reuses. */
@@ -33,6 +34,7 @@ interface SteerPart {
   type?: string;
   steerId?: string;
   files?: Partial<TFile>[];
+  quotes?: string[];
   media?: Array<Record<string, unknown>>;
   [key: string]: unknown;
 }
@@ -49,32 +51,44 @@ export interface StampedSteerMedia {
   steerText: string;
 }
 
+/** The model-bound body for a steer: quoted excerpts prepended as Markdown
+ *  blockquotes, exactly like `prependQuotes` does for regular user turns. The
+ *  persisted part keeps `steer`/`quotes` separate; only this boundary merges. */
+function mergeSteerModelText(text: string, quotes?: string[] | null): string {
+  const normalized = getReferencedQuotes(quotes);
+  return normalized != null ? mergeQuotedText(text, normalized) : text;
+}
+
 /**
  * Encodes authorized file docs for one steer and assembles the multimodal
  * content array, reusing the exact pipeline regular user turns go through:
  * `addFileContextToMessage` + `processAttachments` (single-pass categorize +
  * encode images/documents/videos/audios) on a throwaway message, then the
  * SDK's `formatMessage` for part ordering (no `endpoint` arg — matching the
- * agents payload path, which formats without one).
+ * agents payload path, which formats without one). Quoted excerpts merge into
+ * the text part so the model receives them wherever the content array lands.
  */
 async function encodeSteerContent({
   client,
   text,
+  quotes,
   steerId,
   fileDocs,
 }: {
   client: SteerMediaClient;
   text: string;
+  quotes?: string[] | null;
   steerId: string;
   fileDocs: IMongoFile[];
 }): Promise<SteerMediaResult> {
+  const modelText = mergeSteerModelText(text, quotes);
   const pseudo: PseudoMessage = { messageId: `steer:${steerId}` };
   await client.addFileContextToMessage(pseudo, fileDocs);
   const validated = await client.processAttachments(pseudo, fileDocs);
   const formatted = formatMessage({
     message: {
       role: 'user',
-      content: text,
+      content: modelText,
       image_urls: pseudo.image_urls,
       documents: pseudo.documents,
       videos: pseudo.videos,
@@ -86,7 +100,7 @@ async function encodeSteerContent({
   }
   const content = Array.isArray(formatted.content)
     ? formatted.content
-    : [{ type: ContentTypes.TEXT, text: formatted.content ?? text }];
+    : [{ type: ContentTypes.TEXT, text: formatted.content ?? modelText }];
   const refSource = Array.isArray(validated) && validated.length > 0 ? validated : fileDocs;
   const files = refSource.map(toSteerFileRef).filter((ref): ref is Partial<TFile> => ref != null);
   return { content, files };
@@ -128,16 +142,71 @@ export async function buildSteerMedia({
     .map((id) => docsById.get(id))
     .filter((doc): doc is IMongoFile => doc != null);
   assertFilesAllowed?.(fileDocs);
-  return encodeSteerContent({ client, text: item.text, steerId: item.steerId, fileDocs });
+  return encodeSteerContent({
+    client,
+    text: item.text,
+    quotes: item.quotes,
+    steerId: item.steerId,
+    fileDocs,
+  });
+}
+
+export interface SteerStampTarget {
+  message: { id?: string; messageId?: string; content?: unknown };
+  part: SteerPart;
+  index: number;
+  quotes: string[] | null;
+  encodeFiles: boolean;
+}
+
+export type SteerStampPayload = Array<{
+  id?: string;
+  messageId?: string;
+  role?: string;
+  content?: unknown;
+}>;
+
+/** One pass over the payload for everything the stamp needs. Callers check
+ *  `.length` for the zero-await fast path and hand the result to
+ *  `stampSteerPartMedia`, so the history is never scanned twice. */
+export function collectSteerStampTargets(
+  payload: SteerStampPayload,
+  resendFiles: boolean,
+): SteerStampTarget[] {
+  const targets: SteerStampTarget[] = [];
+  for (let index = 0; index < payload.length; index++) {
+    const message = payload[index];
+    if (message?.role !== 'assistant' || !Array.isArray(message.content)) {
+      continue;
+    }
+    for (const part of message.content as SteerPart[]) {
+      if (part?.type !== ContentTypes.STEER) {
+        continue;
+      }
+      const quotes = getReferencedQuotes(part.quotes);
+      const encodeFiles = resendFiles && Array.isArray(part.files) && part.files.length > 0;
+      if (encodeFiles || quotes != null) {
+        targets.push({ message, part, index, quotes, encodeFiles });
+      }
+    }
+  }
+  return targets;
 }
 
 /**
- * Re-encodes attachments for persisted steer parts of PAST turns and stamps
- * the assembled content array as a transient `media` field, which the SDK's
- * `formatAgentMessages` prefers over the plain text when reconstructing the
- * steer's HumanMessage. Refs are re-encoded per turn — encoded data is never
- * persisted — and parts are replaced immutably so the stamp cannot leak into
- * a message save. Encodes run in parallel after doc resolution.
+ * Re-encodes attachments and re-merges quotes for persisted steer parts of
+ * PAST turns, stamping the assembled content array as a transient `media`
+ * field, which the SDK's `formatAgentMessages` prefers over the plain text
+ * when reconstructing the steer's HumanMessage. Refs are re-encoded per turn
+ * — encoded data is never persisted — and parts are replaced immutably so the
+ * stamp cannot leak into a message save. Encodes run in parallel after doc
+ * resolution.
+ *
+ * Quote-bearing parts are stamped UNCONDITIONALLY (a merged text part is the
+ * only way the excerpts reach the model on replay, mirroring `prependQuotes`
+ * for regular user turns), while file encoding remains gated on the
+ * conversation's `resendFiles` setting — a quote-bearing part whose files are
+ * not resent still replays its quotes, exactly like its text.
  *
  * `docsById` should be the owner-scoped doc map `addPreviousAttachments`
  * already fetched this turn (its single historical-files query collects
@@ -149,85 +218,101 @@ export async function stampSteerPartMedia({
   client,
   user,
   payload,
+  targets,
   docsById,
   getFiles,
+  resendFiles = true,
 }: {
   client: SteerMediaClient;
   user: SteerRequestUser | undefined;
-  payload: Array<{ id?: string; messageId?: string; role?: string; content?: unknown }>;
+  payload: SteerStampPayload;
+  /** Pre-collected via `collectSteerStampTargets` so the caller's zero-await
+   *  probe and this stamp share one payload scan; collected here otherwise. */
+  targets?: SteerStampTarget[];
   docsById?: Map<string, IMongoFile>;
   getFiles: SteerFileFetcher;
+  resendFiles?: boolean;
 }): Promise<StampedSteerMedia[]> {
-  const stampTargets: Array<{
-    message: { id?: string; messageId?: string; content?: unknown };
-    part: SteerPart;
-    index: number;
-  }> = [];
-  for (let index = 0; index < payload.length; index++) {
-    const message = payload[index];
-    if (message?.role !== 'assistant' || !Array.isArray(message.content)) {
-      continue;
-    }
-    for (const part of message.content as SteerPart[]) {
-      if (part?.type === ContentTypes.STEER && Array.isArray(part.files) && part.files.length > 0) {
-        stampTargets.push({ message, part, index });
-      }
-    }
-  }
+  const stampTargets = targets ?? collectSteerStampTargets(payload, resendFiles);
   if (stampTargets.length === 0) {
     return [];
   }
 
   let resolvedDocsById = docsById;
-  if (resolvedDocsById == null) {
-    const allIds = collectFileIds(stampTargets.flatMap(({ part }) => part.files ?? []));
+  const fileTargets = stampTargets.filter(({ encodeFiles }) => encodeFiles);
+  if (resolvedDocsById == null && fileTargets.length > 0) {
+    const allIds = collectFileIds(fileTargets.flatMap(({ part }) => part.files ?? []));
     const filter = buildOwnerFilter(allIds, user);
-    if (filter == null) {
-      return [];
-    }
-    const fileDocs = await getFiles(filter, {}, {});
-    if (!Array.isArray(fileDocs) || fileDocs.length === 0) {
-      return [];
+    if (filter != null) {
+      const fileDocs = await getFiles(filter, {}, {});
+      if (Array.isArray(fileDocs) && fileDocs.length > 0) {
+        resolvedDocsById = new Map(fileDocs.map((file) => [file.file_id, file]));
+      }
     }
-    resolvedDocsById = new Map(fileDocs.map((file) => [file.file_id, file]));
   }
   const docs = resolvedDocsById;
 
   const stamped: Array<StampedSteerMedia | null> = await Promise.all(
-    stampTargets.map(async ({ message, part, index }): Promise<StampedSteerMedia | null> => {
-      const partDocs = (part.files ?? [])
-        .map((file) => (file?.file_id != null ? docs.get(file.file_id) : undefined))
-        .filter((doc): doc is IMongoFile => doc != null);
-      if (partDocs.length === 0) {
-        return null;
-      }
-      try {
-        const { content, files } = await encodeSteerContent({
-          client,
-          text: (part[ContentTypes.STEER] as string | undefined) ?? '',
-          steerId: part.steerId ?? 'replay',
-          fileDocs: partDocs,
-        });
-        message.content = (message.content as SteerPart[]).map((candidate) =>
-          candidate === part ? { ...candidate, media: content } : candidate,
-        );
-        return {
-          index,
-          sourceMessageId: message.messageId ?? message.id,
-          fileIds: (files ?? [])
-            .map((file) => file.file_id)
-            .filter((fileId): fileId is string => typeof fileId === 'string' && fileId.length > 0),
-          media: content,
-          steerText: (part[ContentTypes.STEER] as string | undefined) ?? '',
+    stampTargets.map(
+      async ({ message, part, index, quotes, encodeFiles }): Promise<StampedSteerMedia | null> => {
+        const steerText = (part[ContentTypes.STEER] as string | undefined) ?? '';
+        const partDocs = encodeFiles
+          ? (part.files ?? [])
+              .map((file) => (file?.file_id != null ? docs?.get(file.file_id) : undefined))
+              .filter((doc): doc is IMongoFile => doc != null)
+          : [];
+        const stampPart = (content: Array<Record<string, unknown>>, fileIds: string[]) => {
+          message.content = (message.content as SteerPart[]).map((candidate) =>
+            candidate === part ? { ...candidate, media: content } : candidate,
+          );
+          return {
+            index,
+            sourceMessageId: message.messageId ?? message.id,
+            fileIds,
+            media: content,
+            steerText,
+          };
         };
-      } catch (error) {
-        logger.warn(
-          `[stampSteerPartMedia] Failed to re-encode steer media (steer=${part.steerId}); replaying text only`,
-          error,
-        );
-        return null;
-      }
-    }),
+        /** No authorized docs (or files not resent): a quote-bearing part
+         *  still stamps its merged text so the excerpts replay; a files-only
+         *  part falls back to plain-text replay exactly as before. */
+        const stampMergedTextOnly = () => {
+          if (quotes == null) {
+            return null;
+          }
+          return stampPart(
+            [{ type: ContentTypes.TEXT, text: mergeSteerModelText(steerText, quotes) }],
+            [],
+          );
+        };
+        if (partDocs.length === 0) {
+          return stampMergedTextOnly();
+        }
+        try {
+          const { content, files } = await encodeSteerContent({
+            client,
+            text: steerText,
+            quotes,
+            steerId: part.steerId ?? 'replay',
+            fileDocs: partDocs,
+          });
+          return stampPart(
+            content,
+            (files ?? [])
+              .map((file) => file.file_id)
+              .filter(
+                (fileId): fileId is string => typeof fileId === 'string' && fileId.length > 0,
+              ),
+          );
+        } catch (error) {
+          logger.warn(
+            `[stampSteerPartMedia] Failed to re-encode steer media (steer=${part.steerId}); replaying text only`,
+            error,
+          );
+          return stampMergedTextOnly();
+        }
+      },
+    ),
   );
   return stamped.filter((entry): entry is StampedSteerMedia => entry != null);
 }
diff --git a/packages/api/src/agents/steering/request.ts b/packages/api/src/agents/steering/request.ts
index 632a48799a0..e380535ac41 100644
--- a/packages/api/src/agents/steering/request.ts
+++ b/packages/api/src/agents/steering/request.ts
@@ -17,6 +17,7 @@ import {
 import { toSteerFileRef, collectFileIds, buildOwnerFilter } from './refs';
 import { GenerationJobManager } from '~/stream/GenerationJobManager';
 import { isSteeringSupported } from './runtime';
+import { getReferencedQuotes } from '~/utils';
 
 /** Attachment cap per steer, mirroring the composer's practical limits. */
 export const STEER_MAX_FILES = 10;
@@ -48,6 +49,10 @@ export interface SteerRequestBody {
   text?: unknown;
   clientSteerId?: unknown;
   files?: unknown;
+  /** Quoted excerpts steered with the message ("Add to chat" selections);
+   *  normalized like the chat route's quotes and merged into the model-bound
+   *  turn at the injection boundary. */
+  quotes?: unknown;
   /** Ask the generating replica to seal the live model stream at the next
    *  provider-safe boundary instead of waiting for a tool step. NEVER a
    *  rejection reason: on an SDK without the capability the steer still
@@ -230,6 +235,11 @@ function hasTenantMismatch(
   return metadata?.tenantId != null && metadata.tenantId !== user.tenantId;
 }
 
+/** DELIBERATELY quote-independent: this exact 3-field hash is what EVERY
+ *  deployed replica version computes, so a lost-ACK retry can replay its
+ *  receipt no matter which replica wrote it or reads it. Quote identity is
+ *  enforced separately via `SteerReceipt.requestedQuotesFingerprint`, which
+ *  only quote-aware readers consult. */
 function steerFingerprint(
   text: string,
   files: Partial<TFile>[] | undefined,
@@ -240,6 +250,28 @@ function steerFingerprint(
     .digest('base64url');
 }
 
+/** Normalized-quote identity stored beside (never inside) the fingerprint. */
+function quotesFingerprint(quotes: string[]): string {
+  return createHash('sha256').update(JSON.stringify(quotes)).digest('base64url');
+}
+
+/** Whether a receipt's recorded quote identity accepts this request's quotes.
+ *  An ABSENT record means the receipt was written by a pre-quotes replica (or
+ *  for a quote-less request) — quotes were never part of its contract, so any
+ *  retry of the same words replays (the item carries no quotes; the missing
+ *  `quotesAccepted` echo keeps the client's copy on its chip). A present
+ *  record must match exactly: reusing a clientSteerId with different quotes
+ *  is the same conflict a content-hash mismatch signals. */
+function receiptQuotesCompatible(
+  recorded: string | undefined,
+  requested: string[] | null,
+): boolean {
+  if (recorded == null) {
+    return true;
+  }
+  return requested != null && quotesFingerprint(requested) === recorded;
+}
+
 function receiptResponse(conversationId: string, receipt: SteerReceipt): SteerRequestResult {
   return {
     status: 202,
@@ -252,6 +284,13 @@ function receiptResponse(conversationId: string, receipt: SteerReceipt): SteerRe
       settled: receipt.state !== 'queued' && receipt.state !== 'claimed',
       leftover: receipt.state === 'leftover',
       replayed: true,
+      /** From the DURABLE item, mirroring the fresh 202: a receipt written by
+       *  a pre-quotes replica replays without this marker, telling the client
+       *  its excerpts never attached to the accepted words. */
+      ...(receipt.item.quotes != null &&
+        receipt.item.quotes.length > 0 && {
+          quotesAccepted: true,
+        }),
       ...(receipt.item.preemptRevision != null && {
         preemptRevision: receipt.item.preemptRevision,
       }),
@@ -401,6 +440,10 @@ async function handleSteerRequestInternal(
     return { status: 400, body: { code: filesError } };
   }
 
+  /** Same normalization as the chat route (trim, drop empties, cap count and
+   *  excerpt length) so a steer's quotes obey the caps a normal send does. */
+  const quotes = getReferencedQuotes(body.quotes);
+
   /** streamId === conversationId for resumable agent jobs */
   const streamId = conversationId;
   const wantsPreempt = body.preempt === true;
@@ -430,7 +473,10 @@ async function handleSteerRequestInternal(
       ) {
         return { status: 409, body: { code: 'RUN_REPLACED' } };
       }
-      if (receipt.fingerprint !== fingerprint) {
+      if (
+        receipt.fingerprint !== fingerprint ||
+        !receiptQuotesCompatible(receipt.requestedQuotesFingerprint, quotes)
+      ) {
         return { status: 409, body: { code: 'STEER_IDEMPOTENCY_CONFLICT' } };
       }
       if (
@@ -560,6 +606,19 @@ async function handleSteerRequestInternal(
   if (isAborted(deps.signal)) {
     return { status: 499, body: { code: 'STEER_ABORTED' } };
   }
+  /** The OWNER's execution-bound capability: an upgraded admission replica
+   * must not store quotes (and claim them accepted) for a generation whose
+   * owning drain would silently drop them at injection. This read is only
+   * the FAST PATH — the enqueue transaction re-evaluates the same
+   * marker-equals-execution predicate atomically against the live job and
+   * strips `item.quotes` itself, so a HITL handover landing after this read
+   * (same `createdAt`, invisible to the enqueue fence) cannot smuggle
+   * quotes past a legacy owner. The returned persisted item reflects any
+   * strip, keeping the `quotesAccepted` echo honest; on a missing echo the
+   * client re-stages the excerpts. */
+  const ownerAcceptsQuotes =
+    owner.metadata?.steerQuotesExecutionId != null &&
+    owner.metadata.steerQuotesExecutionId === owner.metadata.providerExecutionId;
   const item: SteerQueueItem = {
     steerId: randomUUID(),
     ...(protocol.value === 2 && typeof clientSteerId === 'string' && { clientSteerId }),
@@ -567,6 +626,7 @@ async function handleSteerRequestInternal(
     userId: user.id ?? '',
     createdAt: Date.now(),
     ...(queuedFiles && { files: queuedFiles }),
+    ...(quotes != null && ownerAcceptsQuotes && { quotes }),
   };
   /**
    * Fenced to the generation the capability decision was made against. The
@@ -588,6 +648,7 @@ async function handleSteerRequestInternal(
       {
         clientSteerId,
         fingerprint,
+        ...(quotes != null && { requestedQuotesFingerprint: quotesFingerprint(quotes) }),
         userId: user.id ?? '',
         ...(user.tenantId && { tenantId: user.tenantId }),
         ...(job.metadata?.agent_id && { agentId: job.metadata.agent_id }),
@@ -600,7 +661,11 @@ async function handleSteerRequestInternal(
     if (typeof result === 'number') {
       depth = result;
     } else {
-      if (!('fingerprint' in result) || result.fingerprint !== fingerprint) {
+      if (
+        !('fingerprint' in result) ||
+        result.fingerprint !== fingerprint ||
+        !receiptQuotesCompatible(result.requestedQuotesFingerprint, quotes)
+      ) {
         return { status: 409, body: { code: 'STEER_IDEMPOTENCY_CONFLICT' } };
       }
       if (result.userId !== (user.id ?? '') || hasTenantMismatch(result, user)) {
@@ -724,6 +789,14 @@ async function handleSteerRequestInternal(
       position: depth,
       conversationId,
       preempt: preemptArmed,
+      /** Echoed from the DURABLE item so the client can tell whether its
+       *  quoted excerpts will actually inject. A pre-quotes replica never
+       *  sets this, and the client re-stages the excerpts on that absence —
+       *  a 202 must not silently drop model-bound context. */
+      ...(persistedItem.quotes != null &&
+        persistedItem.quotes.length > 0 && {
+          quotesAccepted: true,
+        }),
       ...(protocol.value === 2 && preemptRevision != null && { preemptRevision }),
     },
   };
diff --git a/packages/api/src/agents/steering/runtime.ts b/packages/api/src/agents/steering/runtime.ts
index 31cb0a9e932..502c8f9308a 100644
--- a/packages/api/src/agents/steering/runtime.ts
+++ b/packages/api/src/agents/steering/runtime.ts
@@ -9,6 +9,7 @@ import type {
 } from '@librechat/agents';
 import type { SteerQueueItem } from '~/stream/interfaces/IJobStore';
 import { GenerationJobManager } from '~/stream/GenerationJobManager';
+import { getReferencedQuotes, mergeQuotedText } from '~/utils';
 
 type SteerDrainOutput = HookOutputByEvent['PostToolBatch'];
 
@@ -168,9 +169,14 @@ async function drainAndBuildInjections(opts: SteerDrainHookOptions): Promise<Inj
           );
         }
       }
+      /** The media path already merged quotes into its text part; the plain
+       *  path (no files, or a degraded encode) merges here so the excerpts
+       *  reach the model exactly like `prependQuotes` on a normal turn. */
+      const quotes = getReferencedQuotes(item.quotes);
+      const textContent = quotes != null ? mergeQuotedText(item.text, quotes) : item.text;
       injectedMessages.push({
         role: 'user' as const,
-        content: (media?.content ?? item.text) as InjectedMessage['content'],
+        content: (media?.content ?? textContent) as InjectedMessage['content'],
         source: 'steer' as const,
       });
     }
diff --git a/packages/api/src/protection/adapters/submissions.spec.ts b/packages/api/src/protection/adapters/submissions.spec.ts
index ab7b71880cb..a86b1feee74 100644
--- a/packages/api/src/protection/adapters/submissions.spec.ts
+++ b/packages/api/src/protection/adapters/submissions.spec.ts
@@ -63,6 +63,34 @@ describe('submitted content adapters', () => {
     });
   });
 
+  it('inspects persisted steer-part quotes as quote fragments', () => {
+    // Steer parts persist their excerpts under `content[i].quotes`, mirroring
+    // the top-level `message.quotes` — import and share preflights must see
+    // them or blocked data could ride in on a quoted steer.
+    const message = {
+      role: 'assistant',
+      content: [
+        {
+          type: 'steer',
+          steer: 'about the selection',
+          steerId: 's1',
+          quotes: ['quoted secret excerpt'],
+        },
+      ],
+    };
+
+    expect(fieldValues(extractStoredMessageContent(message))).toEqual(
+      expect.arrayContaining([
+        {
+          source: 'message',
+          field: 'quote',
+          text: 'quoted secret excerpt',
+          path: '/content/0/quotes/0',
+        },
+      ]),
+    );
+  });
+
   it('classifies persisted and imported summary content parts as message summaries', () => {
     const message = {
       content: [{ type: 'summary', text: 'persisted summary text' }],
diff --git a/packages/api/src/protection/adapters/submissions.ts b/packages/api/src/protection/adapters/submissions.ts
index 168c313d2f6..e57f4638b8a 100644
--- a/packages/api/src/protection/adapters/submissions.ts
+++ b/packages/api/src/protection/adapters/submissions.ts
@@ -187,6 +187,7 @@ export interface StoredMessagePartInput {
   readonly original?: string;
   readonly updated?: string;
   readonly steer?: string;
+  readonly quotes?: readonly (string | { readonly text?: string } | null | undefined)[];
   readonly error?: string;
   readonly image_url?: string | { readonly url?: string };
   readonly video_url?: { readonly url?: string };
@@ -368,6 +369,7 @@ const STORED_MESSAGE_HANDLED_PART_PATH_SUFFIXES = new Set([
   '/original',
   '/updated',
   '/steer',
+  '/quotes',
   '/error',
   '/image_url',
   '/video_url',
@@ -1564,7 +1566,30 @@ function extractStoredMessageContentWithBudget(
             part?.files,
             STORED_MESSAGE_ATTACHMENT_ARRAY_SCOPES,
           );
+          /** Steer parts persist their quoted excerpts under `quotes`, exactly
+           *  like the top-level `message.quotes`: model-bound user text that
+           *  import and share preflights must inspect as quote fragments. */
+          const partQuotes = captureBoundedArray<string | { readonly text?: string }>(
+            part?.quotes,
+            STORED_MESSAGE_QUOTE_ARRAY_SCOPES,
+          );
           const toolCall = part?.tool_call;
+          withReservedTraversalWork(
+            hasArrayValues(nestedContent) + hasArrayValues(partFiles) + (toolCall != null ? 1 : 0),
+            () =>
+              visitBoundedArray<string | { readonly text?: string }>(
+                partQuotes,
+                STORED_MESSAGE_QUOTE_ARRAY_SCOPES,
+                (quote, quoteIndex) => {
+                  pushString(fragments, typeof quote === 'string' ? quote : quote?.text, {
+                    id: `stored-message.content.${index}.quote.${quoteIndex}`,
+                    path: `/content/${index}/quotes/${quoteIndex}`,
+                    source: 'message',
+                    field: 'quote',
+                  });
+                },
+              ),
+          );
           withReservedTraversalWork(hasArrayValues(partFiles) + (toolCall != null ? 1 : 0), () =>
             visitBoundedArray<{
               readonly text?: string | { readonly value?: string };
diff --git a/packages/api/src/stream/ApprovalLifecycle.ts b/packages/api/src/stream/ApprovalLifecycle.ts
index ac6961af514..fb5e1b03f25 100644
--- a/packages/api/src/stream/ApprovalLifecycle.ts
+++ b/packages/api/src/stream/ApprovalLifecycle.ts
@@ -348,6 +348,18 @@ export class ApprovalLifecycle {
       await this.expire(streamId, expectedActionId ?? job.pendingAction.actionId, job.createdAt);
       return false;
     }
+    /** Translate the resuming owner's transient quote-capability assertion
+     * into its execution-bound marker (see `steerQuotesExecutionId`). A
+     * legacy resumer never reaches this code — its execution rewrite alone
+     * invalidates the previous owner's marker. */
+    const { steerQuotesCapable, ...ownerPatch } = resumePatch ?? {};
+    const boundPatch = {
+      ...ownerPatch,
+      ...(steerQuotesCapable === true &&
+        typeof ownerPatch.providerExecutionId === 'string' && {
+          steerQuotesExecutionId: ownerPatch.providerExecutionId,
+        }),
+    };
     const resumed = await this.store.transitionStatus(streamId, {
       from: 'requires_action',
       to: 'running',
@@ -357,7 +369,7 @@ export class ApprovalLifecycle {
       /** Ownership can move across replicas on resume. Owner-specific fields
        *  must change in this SAME CAS: once status is `running`, steering
        *  routes are live and may atomically inspect them. */
-      patch: { lastActiveAt: Date.now(), ...resumePatch },
+      patch: { lastActiveAt: Date.now(), ...boundPatch },
       expectActionId: expectedActionId,
       expectCreatedAt: job.createdAt,
     });
diff --git a/packages/api/src/stream/GenerationJobManager.ts b/packages/api/src/stream/GenerationJobManager.ts
index e2998d04769..632c1ce1aaa 100644
--- a/packages/api/src/stream/GenerationJobManager.ts
+++ b/packages/api/src/stream/GenerationJobManager.ts
@@ -2035,8 +2035,15 @@ class GenerationJobManagerClass {
     const tenantId = getTenantId();
     const safeTenantId = tenantId && tenantId !== SYSTEM_TENANT_ID ? tenantId : undefined;
     const creationAttemptId = randomUUID();
+    const sanitizedMetadata = sanitizeJobMetadata(options.initialMetadata ?? {});
+    /** Translate the transient capability assertion into its execution-bound
+     * marker: valid only while `providerExecutionId` still names this owner,
+     * so a legacy replica winning a later HITL resume (which rewrites the
+     * execution id without knowing this field) self-invalidates it. */
+    const { steerQuotesCapable, ...storedMetadata } = sanitizedMetadata;
     const initialMetadata = {
-      ...sanitizeJobMetadata(options.initialMetadata ?? {}),
+      ...storedMetadata,
+      ...(steerQuotesCapable === true && { steerQuotesExecutionId: creationAttemptId }),
       providerExecutionId: creationAttemptId,
       providerDrained: true,
     };
@@ -2566,6 +2573,9 @@ class GenerationJobManagerClass {
         // Surface the owning replica's seal capability so the steer route can
         // honour it instead of probing its own (possibly older) SDK.
         preemptCapable: jobData.preemptCapable,
+        // Same owner-recorded pattern for quote handling, execution-bound so a
+        // legacy resume's execution rewrite invalidates a stale assertion.
+        steerQuotesExecutionId: jobData.steerQuotesExecutionId,
         providerExecutionId: jobData.providerExecutionId,
         providerDrained: jobData.providerDrained,
         steersClosed: jobData.steersClosed,
diff --git a/packages/api/src/stream/SteerRecovery.ts b/packages/api/src/stream/SteerRecovery.ts
index f5a680ca81a..9f624dd88a3 100644
--- a/packages/api/src/stream/SteerRecovery.ts
+++ b/packages/api/src/stream/SteerRecovery.ts
@@ -1,4 +1,5 @@
 import type { TFile, TPendingSteer } from 'librechat-data-provider';
+import { getReferencedQuotes } from '~/utils';
 
 /** Immutable user-visible payload a parked steer recovery is allowed to submit. */
 export interface RecoveredSteerPayload {
@@ -6,6 +7,11 @@ export interface RecoveredSteerPayload {
   /** Sorted, unique file ids. Display metadata is deliberately excluded: the
    * normal send path re-resolves files by owner and only identity is binding. */
   fileIds: string[];
+  /** Normalized quoted excerpts, order-significant. Model-bound exactly like
+   * the text, so the proof must bind them too: a stale client presenting the
+   * same recoverySteerId with altered or missing quotes must not consume the
+   * parked source. Empty when the source carried none. */
+  quotes: string[];
 }
 
 /** A recovery-shaped request did not reproduce the parked source exactly. */
@@ -47,12 +53,16 @@ export function canonicalRecoveryFileIds(files: unknown): string[] | null {
 export function buildRecoveredSteerPayload(
   text: unknown,
   files: unknown,
+  quotes?: unknown,
 ): RecoveredSteerPayload | null {
   if (typeof text !== 'string') {
     return null;
   }
   const fileIds = canonicalRecoveryFileIds(files);
-  return fileIds == null ? null : { text, fileIds };
+  if (fileIds == null) {
+    return null;
+  }
+  return { text, fileIds, quotes: getReferencedQuotes(quotes) ?? [] };
 }
 
 export function isRecoveredSteerPayload(value: unknown): value is RecoveredSteerPayload {
@@ -65,19 +75,24 @@ export function isRecoveredSteerPayload(value: unknown): value is RecoveredSteer
     Array.isArray(payload.fileIds) &&
     payload.fileIds.every((id) => typeof id === 'string' && id.length > 0) &&
     payload.fileIds.length === new Set(payload.fileIds).size &&
-    payload.fileIds.every((id, index) => index === 0 || payload.fileIds![index - 1] < id)
+    payload.fileIds.every((id, index) => index === 0 || payload.fileIds![index - 1] < id) &&
+    Array.isArray(payload.quotes) &&
+    payload.quotes.every((quote) => typeof quote === 'string' && quote.length > 0)
   );
 }
 
 export function recoveredSteerPayloadMatches(
-  item: Pick<TPendingSteer, 'text' | 'files'>,
+  item: Pick<TPendingSteer, 'text' | 'files' | 'quotes'>,
   expected: RecoveredSteerPayload,
 ): boolean {
   const fileIds = canonicalRecoveryFileIds(item.files);
+  const itemQuotes = getReferencedQuotes(item.quotes) ?? [];
   return (
     item.text === expected.text &&
     fileIds != null &&
     fileIds.length === expected.fileIds.length &&
-    fileIds.every((id, index) => id === expected.fileIds[index])
+    fileIds.every((id, index) => id === expected.fileIds[index]) &&
+    itemQuotes.length === expected.quotes.length &&
+    itemQuotes.every((quote, index) => quote === expected.quotes[index])
   );
 }
diff --git a/packages/api/src/stream/SteeringLifecycle.ts b/packages/api/src/stream/SteeringLifecycle.ts
index 33ac4c16603..7ccde362a0c 100644
--- a/packages/api/src/stream/SteeringLifecycle.ts
+++ b/packages/api/src/stream/SteeringLifecycle.ts
@@ -22,6 +22,7 @@ export function toPendingSteer(item: SteerQueueItem): TPendingSteer {
     text: item.text,
     createdAt: item.createdAt,
     ...(item.files && item.files.length > 0 && { files: item.files }),
+    ...(item.quotes && item.quotes.length > 0 && { quotes: item.quotes }),
     ...(item.preempt === true && { preempt: true }),
     ...(item.preemptRevision != null && { preemptRevision: item.preemptRevision }),
   };
diff --git a/packages/api/src/stream/__tests__/RedisJobStore.spec.ts b/packages/api/src/stream/__tests__/RedisJobStore.spec.ts
index 5610d3e59cc..dc85ee363e5 100644
--- a/packages/api/src/stream/__tests__/RedisJobStore.spec.ts
+++ b/packages/api/src/stream/__tests__/RedisJobStore.spec.ts
@@ -348,6 +348,7 @@ describe('RedisJobStore', () => {
       promptTokens: 0,
       discoveredTools: [],
       preemptCapable: true,
+      steerQuotesExecutionId: 'exec-1',
       generationProtocolVersion: 2,
       resolvedAskUserQuestions: [
         {
@@ -370,6 +371,7 @@ describe('RedisJobStore', () => {
      * degrading to ordinary steering in every Redis deployment.
      */
     expect(job.preemptCapable).toBe(true);
+    expect(job.steerQuotesExecutionId).toBe('exec-1');
     expect(job.generationProtocolVersion).toBe(2);
     expect(job.checkpointNamespace).toBe(String(job.createdAt));
     expect(job.resolvedAskUserQuestions).toEqual([
diff --git a/packages/api/src/stream/__tests__/RedisJobStore.stream_integration.spec.ts b/packages/api/src/stream/__tests__/RedisJobStore.stream_integration.spec.ts
index f3c25032aa6..98fa0deb54d 100644
--- a/packages/api/src/stream/__tests__/RedisJobStore.stream_integration.spec.ts
+++ b/packages/api/src/stream/__tests__/RedisJobStore.stream_integration.spec.ts
@@ -3118,7 +3118,7 @@ describe('RedisJobStore Integration Tests', () => {
         undefined,
         undefined,
         undefined,
-        { text: 'kept', fileIds: [] },
+        { text: 'kept', fileIds: [], quotes: [] },
       );
       expect(await store.claimParkedSteers(streamId, 'steer-user')).toBeUndefined();
       expect(await ioredisClient.exists(`stream:{${streamId}}:parked`)).toBe(1);
@@ -3145,7 +3145,7 @@ describe('RedisJobStore Integration Tests', () => {
         undefined,
         undefined,
         undefined,
-        { text: 'kept', fileIds: [] },
+        { text: 'kept', fileIds: [], quotes: [] },
       );
       expect(
         await store.consumeParkedSteer(
@@ -3163,8 +3163,12 @@ describe('RedisJobStore Integration Tests', () => {
     });
 
     test.each([
-      ['changed text', { text: 'forged words', fileIds: ['file-a', 'file-b'] }],
-      ['changed files', { text: 'original words', fileIds: ['file-a', 'file-c'] }],
+      ['changed text', { text: 'forged words', fileIds: ['file-a', 'file-b'], quotes: [] }],
+      ['changed files', { text: 'original words', fileIds: ['file-a', 'file-c'], quotes: [] }],
+      [
+        'changed quotes',
+        { text: 'original words', fileIds: ['file-a', 'file-b'], quotes: ['forged excerpt'] },
+      ],
     ])('atomically refuses parked recovery with %s', async (_label, proof) => {
       if (!ioredisClient) {
         return;
@@ -4177,6 +4181,7 @@ describe('RedisJobStore Integration Tests', () => {
           {
             text: item.text,
             fileIds: (item.files ?? []).flatMap((file) => file.file_id ?? []).sort(),
+            quotes: item.quotes ?? [],
           },
         );
 
@@ -4267,6 +4272,7 @@ describe('RedisJobStore Integration Tests', () => {
           {
             text: item.text,
             fileIds: (item.files ?? []).flatMap((file) => file.file_id ?? []).sort(),
+            quotes: item.quotes ?? [],
           },
         );
         await expect(
diff --git a/packages/api/src/stream/__tests__/protocolRollout.spec.ts b/packages/api/src/stream/__tests__/protocolRollout.spec.ts
index 6f844ef3b66..5d53322c738 100644
--- a/packages/api/src/stream/__tests__/protocolRollout.spec.ts
+++ b/packages/api/src/stream/__tests__/protocolRollout.spec.ts
@@ -110,7 +110,7 @@ describe('generation protocol rollout storage', () => {
       undefined,
       undefined,
       undefined,
-      { text: leased.text, fileIds: [] },
+      { text: leased.text, fileIds: [], quotes: [] },
     );
 
     const downgraded = await store.claimParkedSteersDetailed(streamId, 'user-1', undefined, 1);
@@ -189,7 +189,7 @@ describe('generation protocol rollout storage', () => {
         undefined,
         undefined,
         undefined,
-        { text: 'legacy words', fileIds: [] },
+        { text: 'legacy words', fileIds: [], quotes: [] },
       ),
     ).rejects.toMatchObject({ code: 'RECOVERY_PAYLOAD_MISMATCH' });
   });
diff --git a/packages/api/src/stream/__tests__/protocolRollout.stream_integration.spec.ts b/packages/api/src/stream/__tests__/protocolRollout.stream_integration.spec.ts
index f75a4787282..478edcc1027 100644
--- a/packages/api/src/stream/__tests__/protocolRollout.stream_integration.spec.ts
+++ b/packages/api/src/stream/__tests__/protocolRollout.stream_integration.spec.ts
@@ -135,7 +135,7 @@ describe('Redis generation protocol rollout bridge', () => {
       undefined,
       undefined,
       undefined,
-      { text: leased.text, fileIds: [] },
+      { text: leased.text, fileIds: [], quotes: [] },
     );
 
     const downgraded = await store.claimParkedSteersDetailed(streamId, 'user-1', undefined, 1);
@@ -191,7 +191,7 @@ describe('Redis generation protocol rollout bridge', () => {
         undefined,
         undefined,
         undefined,
-        { text: 'legacy words', fileIds: [] },
+        { text: 'legacy words', fileIds: [], quotes: [] },
       ),
     ).rejects.toMatchObject({ code: 'RECOVERY_PAYLOAD_MISMATCH' });
   });
diff --git a/packages/api/src/stream/__tests__/steerReceiptIntegrity.spec.ts b/packages/api/src/stream/__tests__/steerReceiptIntegrity.spec.ts
index 248f2e1d036..99037c953a5 100644
--- a/packages/api/src/stream/__tests__/steerReceiptIntegrity.spec.ts
+++ b/packages/api/src/stream/__tests__/steerReceiptIntegrity.spec.ts
@@ -158,6 +158,7 @@ describe('InMemoryJobStore steer receipt integrity', () => {
         {
           text: item.text,
           fileIds: (item.files ?? []).flatMap((file) => file.file_id ?? []).sort(),
+          quotes: item.quotes ?? [],
         },
       );
 
@@ -209,6 +210,7 @@ describe('InMemoryJobStore steer receipt integrity', () => {
         {
           text: item.text,
           fileIds: (item.files ?? []).flatMap((file) => file.file_id ?? []).sort(),
+          quotes: item.quotes ?? [],
         },
       );
 
diff --git a/packages/api/src/stream/__tests__/steering.spec.ts b/packages/api/src/stream/__tests__/steering.spec.ts
index 86442dda130..b8355781f64 100644
--- a/packages/api/src/stream/__tests__/steering.spec.ts
+++ b/packages/api/src/stream/__tests__/steering.spec.ts
@@ -51,6 +51,17 @@ describe('SteeringLifecycle via GenerationJobManager.steering (in-memory)', () =
     };
   }
 
+  describe('toPendingSteer', () => {
+    test('keeps quotes in the client-safe projection while dropping userId', () => {
+      const projected = toPendingSteer({
+        ...buildSteer('with context'),
+        quotes: ['the excerpt'],
+      });
+      expect(projected.quotes).toEqual(['the excerpt']);
+      expect(projected).not.toHaveProperty('userId');
+    });
+  });
+
   describe('enqueue', () => {
     test('appends to a running job and returns the queue depth', async () => {
       const streamId = 'steer-enqueue';
@@ -286,6 +297,103 @@ describe('SteeringLifecycle via GenerationJobManager.steering (in-memory)', () =
     });
   });
 
+  describe('execution-bound quote capability', () => {
+    function pauseAction(streamId: string) {
+      const payload = buildToolApprovalPayload([
+        { name: 'shell', arguments: { command: 'ls' }, tool_call_id: 'call_qc' },
+      ]);
+      return buildPendingAction(payload, {
+        streamId,
+        conversationId: streamId,
+        runId: 'run-qc',
+        responseMessageId: 'msg-qc',
+      });
+    }
+
+    test('a capable resume re-binds the marker to its own execution', async () => {
+      const streamId = 'steer-quote-capability-resume';
+      const job = await manager.createJob(streamId, 'user-1', undefined, {
+        initialMetadata: { steerQuotesCapable: true },
+      });
+      expect(await manager.approvals.pause(streamId, pauseAction(streamId))).toBe(true);
+
+      expect(
+        await manager.approvals.resolve(
+          streamId,
+          undefined,
+          { steerQuotesCapable: true, providerExecutionId: 'resumed-exec', providerDrained: true },
+          job.createdAt,
+        ),
+      ).toBe(true);
+
+      const resumed = await manager.getJob(streamId);
+      expect(resumed?.metadata.steerQuotesExecutionId).toBe('resumed-exec');
+      const depth = await manager.steering.enqueue(streamId, {
+        ...buildSteer('quoted after resume'),
+        quotes: ['kept excerpt'],
+      });
+      expect(depth).toBe(1);
+      const [queued] = await manager.steering.peek(streamId);
+      expect(queued.quotes).toEqual(['kept excerpt']);
+    });
+
+    test('a legacy resume (no assertion) invalidates the previous marker atomically', async () => {
+      const streamId = 'steer-quote-capability-legacy-resume';
+      const job = await manager.createJob(streamId, 'user-1', undefined, {
+        initialMetadata: { steerQuotesCapable: true },
+      });
+      expect(await manager.approvals.pause(streamId, pauseAction(streamId))).toBe(true);
+
+      // A pre-quotes replica's patch rewrites the execution id but cannot
+      // know the marker field — exactly the omit-not-clear shape.
+      expect(
+        await manager.approvals.resolve(
+          streamId,
+          undefined,
+          { providerExecutionId: 'legacy-exec', providerDrained: true },
+          job.createdAt,
+        ),
+      ).toBe(true);
+
+      await manager.steering.enqueue(streamId, {
+        ...buildSteer('quoted after legacy resume'),
+        quotes: ['dropped excerpt'],
+      });
+      const [queued] = await manager.steering.peek(streamId);
+      expect(queued).not.toHaveProperty('quotes');
+    });
+  });
+
+  describe('recovered-steer payload proof', () => {
+    const { buildRecoveredSteerPayload, recoveredSteerPayloadMatches } =
+      jest.requireActual<typeof import('~/stream/SteerRecovery')>('~/stream/SteerRecovery');
+
+    test('binds normalized quotes into the proof (empty when none)', () => {
+      expect(buildRecoveredSteerPayload('words', undefined)).toEqual({
+        text: 'words',
+        fileIds: [],
+        quotes: [],
+      });
+      expect(buildRecoveredSteerPayload('words', undefined, ['  kept  ', ''])).toEqual({
+        text: 'words',
+        fileIds: [],
+        quotes: ['kept'],
+      });
+    });
+
+    test('a recovery matches only when the quotes match, order-significant', () => {
+      const item = { text: 'words', quotes: ['first', 'second'] };
+      const proofFor = (quotes?: unknown) => buildRecoveredSteerPayload('words', undefined, quotes);
+      expect(recoveredSteerPayloadMatches(item, proofFor(['first', 'second'])!)).toBe(true);
+      expect(recoveredSteerPayloadMatches(item, proofFor(['second', 'first'])!)).toBe(false);
+      expect(recoveredSteerPayloadMatches(item, proofFor(['first'])!)).toBe(false);
+      // A stale client omitting the quotes must not consume the parked source.
+      expect(recoveredSteerPayloadMatches(item, proofFor(undefined)!)).toBe(false);
+      // Quote-less sources keep matching quote-less recoveries (pre-quotes parity).
+      expect(recoveredSteerPayloadMatches({ text: 'words' }, proofFor(undefined)!)).toBe(true);
+    });
+  });
+
   describe('park / claim (no-subscriber recovery)', () => {
     const owner = { userId: 'user-1' };
 
@@ -430,7 +538,7 @@ describe('SteeringLifecycle via GenerationJobManager.steering (in-memory)', () =
 
       const failedRecovery = await manager.createJob(streamId, 'user-1', undefined, {
         recoveredSteerId: 'p3',
-        recoveredSteerPayload: { text: 'stale', fileIds: [] },
+        recoveredSteerPayload: { text: 'stale', fileIds: [], quotes: [] },
       });
       expect(await manager.steering.claim(streamId, owner)).toEqual([]);
 
@@ -443,7 +551,7 @@ describe('SteeringLifecycle via GenerationJobManager.steering (in-memory)', () =
 
       const persistedRecovery = await manager.createJob(streamId, 'user-1', undefined, {
         recoveredSteerId: 'p3',
-        recoveredSteerPayload: { text: 'stale', fileIds: [] },
+        recoveredSteerPayload: { text: 'stale', fileIds: [], quotes: [] },
       });
       expect(
         await manager.steering.consumeRecovered(streamId, 'p3', owner, persistedRecovery.createdAt),
@@ -452,8 +560,8 @@ describe('SteeringLifecycle via GenerationJobManager.steering (in-memory)', () =
     });
 
     test.each([
-      ['changed text', { text: 'forged words', fileIds: ['file-a', 'file-b'] }],
-      ['changed files', { text: 'original words', fileIds: ['file-a', 'file-c'] }],
+      ['changed text', { text: 'forged words', fileIds: ['file-a', 'file-b'], quotes: [] }],
+      ['changed files', { text: 'original words', fileIds: ['file-a', 'file-c'], quotes: [] }],
     ])(
       'refuses recovery with %s without leasing or consuming the source',
       async (_label, proof) => {
diff --git a/packages/api/src/stream/implementations/InMemoryJobStore.ts b/packages/api/src/stream/implementations/InMemoryJobStore.ts
index 7718af55729..120048f6135 100644
--- a/packages/api/src/stream/implementations/InMemoryJobStore.ts
+++ b/packages/api/src/stream/implementations/InMemoryJobStore.ts
@@ -1585,6 +1585,12 @@ export class InMemoryJobStore implements IJobStoreV2 {
         ...(job.preemptCapable === true && { preempt: true }),
       }),
     };
+    if (
+      persisted.quotes != null &&
+      (job.steerQuotesExecutionId == null || job.steerQuotesExecutionId !== job.providerExecutionId)
+    ) {
+      delete persisted.quotes;
+    }
     queue.push(persisted);
     return { item: { ...persisted }, position: queue.length };
   }
@@ -1703,6 +1709,12 @@ export class InMemoryJobStore implements IJobStoreV2 {
         ...(job.preemptCapable === true && { preempt: true }),
       }),
     };
+    if (
+      persisted.quotes != null &&
+      (job.steerQuotesExecutionId == null || job.steerQuotesExecutionId !== job.providerExecutionId)
+    ) {
+      delete persisted.quotes;
+    }
     queue.push(persisted);
     const receipt: SteerReceipt = {
       ...receiptInput,
diff --git a/packages/api/src/stream/implementations/RedisJobStore.ts b/packages/api/src/stream/implementations/RedisJobStore.ts
index 56addef3465..78956eb7478 100644
--- a/packages/api/src/stream/implementations/RedisJobStore.ts
+++ b/packages/api/src/stream/implementations/RedisJobStore.ts
@@ -203,6 +203,7 @@ const JOB_CAS_LUA =
   'local clientItem = { steerId = item.steerId, text = item.text, createdAt = item.createdAt } ' +
   'if item.clientSteerId then clientItem.clientSteerId = item.clientSteerId end ' +
   'if item.files then clientItem.files = item.files end ' +
+  'if item.quotes then clientItem.quotes = item.quotes end ' +
   'if item.preempt then clientItem.preempt = item.preempt end ' +
   'if item.preemptRevision then clientItem.preemptRevision = item.preemptRevision end ' +
   'projected[#projected + 1] = clientItem ' +
@@ -460,10 +461,20 @@ const JOB_CREATE_LUA =
   'local expectedSeen = {} for i = 1, #decoded.fileIds do local fileId = decoded.fileIds[i] ' +
   'if type(fileId) ~= "string" or fileId == "" or expectedSeen[fileId] then ' +
   'return { "", "", "0", "recovery_payload_mismatch" } end expectedSeen[fileId] = true end ' +
+  'if decoded.quotes ~= nil then if not isDenseArray(decoded.quotes) then ' +
+  'return { "", "", "0", "recovery_payload_mismatch" } end ' +
+  'for i = 1, #decoded.quotes do if type(decoded.quotes[i]) ~= "string" or decoded.quotes[i] == "" then ' +
+  'return { "", "", "0", "recovery_payload_mismatch" } end end end ' +
   'expectedRecovery = decoded elseif ARGV[9] ~= "" then ' +
   'return { "", "", "0", "recovery_payload_mismatch" } end ' +
   'local function recoveryMatches(item, expected) ' +
   'if not expected or type(item.text) ~= "string" or item.text ~= expected.text then return false end ' +
+  // Quotes are model-bound like the text: order-significant identity, with a
+  // missing array on either side reading as empty (pre-quotes compatibility).
+  'local expectedQuotes = expected.quotes or {} local itemQuotes = item.quotes ' +
+  'if itemQuotes ~= nil and not isDenseArray(itemQuotes) then return false end ' +
+  'itemQuotes = itemQuotes or {} if #itemQuotes ~= #expectedQuotes then return false end ' +
+  'for i = 1, #itemQuotes do if itemQuotes[i] ~= expectedQuotes[i] then return false end end ' +
   'local actualSeen = {} local actualCount = 0 local files = item.files ' +
   'if files then if not isDenseArray(files) then return false end ' +
   'for i = 1, #files do local file = files[i] ' +
@@ -505,7 +516,8 @@ const JOB_CREATE_LUA =
   'if ok and item.steerId and not seen[item.steerId] then seen[item.steerId] = true ' +
   'local projected = { steerId = item.steerId, text = item.text, createdAt = item.createdAt } ' +
   'if item.clientSteerId then projected.clientSteerId = item.clientSteerId end ' +
-  'if item.files then projected.files = item.files end if item.preempt then projected.preempt = item.preempt end ' +
+  'if item.files then projected.files = item.files end if item.quotes then projected.quotes = item.quotes end ' +
+  'if item.preempt then projected.preempt = item.preempt end ' +
   'if item.preemptRevision then projected.preemptRevision = item.preemptRevision end ' +
   'merged[#merged + 1] = projected receiptUpdates[#receiptUpdates + 1] = item end end end end ' +
   'local recoveryOwnerMatches = parkedUserId == ARGV[6] and ' +
@@ -682,7 +694,8 @@ const STALE_JOB_DELETE_LUA =
   'if item.steerId and not seen[item.steerId] then seen[item.steerId] = true fullItems[#fullItems + 1] = item ' +
   'local clientItem = { steerId = item.steerId, text = item.text, createdAt = item.createdAt } ' +
   'if item.clientSteerId then clientItem.clientSteerId = item.clientSteerId end ' +
-  'if item.files then clientItem.files = item.files end if item.preempt then clientItem.preempt = item.preempt end ' +
+  'if item.files then clientItem.files = item.files end if item.quotes then clientItem.quotes = item.quotes end ' +
+  'if item.preempt then clientItem.preempt = item.preempt end ' +
   'if item.preemptRevision then clientItem.preemptRevision = item.preemptRevision end ' +
   'projected[#projected + 1] = clientItem end ' +
   'if generationProtocol == 2 and item.clientSteerId then local raw = redis.call("HGET", KEYS[8], item.clientSteerId) ' +
@@ -932,6 +945,7 @@ const STEER_ENQUEUE_VERSIONED_LUA =
   'if redis.call("HGET", KEYS[1], "steersClosed") == "1" then return -1 end ' +
   'if redis.call("LLEN", KEYS[2]) >= tonumber(ARGV[3]) then return -2 end ' +
   'local item = cjson.decode(ARGV[1]) ' +
+  'if item.quotes then local qexec = redis.call("HGET", KEYS[1], "steerQuotesExecutionId") if not qexec or qexec == "" or qexec ~= redis.call("HGET", KEYS[1], "providerExecutionId") then item.quotes = nil end end ' +
   'if ARGV[5] == "1" then item.preemptRevision = 1 ' +
   'if redis.call("HGET", KEYS[1], "preemptCapable") == "1" then item.preempt = true end end ' +
   'local itemJson = cjson.encode(item) ' +
@@ -969,7 +983,10 @@ const STEER_ENQUEUE_RECEIPT_LUA =
   'if redis.call("HGET", KEYS[1], "status") ~= "running" then return -1 end ' +
   'if redis.call("HGET", KEYS[1], "steersClosed") == "1" then return -1 end ' +
   'if redis.call("LLEN", KEYS[2]) >= tonumber(ARGV[3]) then return -2 end ' +
-  'local legacyItem = cjson.decode(ARGV[1]) if ARGV[7] == "1" then legacyItem.preemptRevision = 1 ' +
+  'local legacyItem = cjson.decode(ARGV[1]) ' +
+  'if legacyItem.quotes then local qexec = redis.call("HGET", KEYS[1], "steerQuotesExecutionId") ' +
+  'if not qexec or qexec == "" or qexec ~= redis.call("HGET", KEYS[1], "providerExecutionId") then legacyItem.quotes = nil end end ' +
+  'if ARGV[7] == "1" then legacyItem.preemptRevision = 1 ' +
   'if redis.call("HGET", KEYS[1], "preemptCapable") == "1" then legacyItem.preempt = true end end ' +
   'redis.call("RPUSH", KEYS[2], cjson.encode(legacyItem)) ' +
   'redis.call("EXPIRE", KEYS[2], tonumber(ARGV[2])) ' +
@@ -980,6 +997,7 @@ const STEER_ENQUEUE_RECEIPT_LUA =
   'if redis.call("LLEN", KEYS[2]) >= tonumber(ARGV[3]) then return -2 end ' +
   'if redis.call("ZCARD", KEYS[4]) >= tonumber(ARGV[9]) then return -3 end ' +
   'local item = cjson.decode(ARGV[1]) ' +
+  'if item.quotes then local qexec = redis.call("HGET", KEYS[1], "steerQuotesExecutionId") if not qexec or qexec == "" or qexec ~= redis.call("HGET", KEYS[1], "providerExecutionId") then item.quotes = nil end end ' +
   'if ARGV[7] == "1" then ' +
   'item.preemptRevision = 1 ' +
   'if redis.call("HGET", KEYS[1], "preemptCapable") == "1" then item.preempt = true end ' +
@@ -1475,6 +1493,7 @@ const STEER_CLOSE_DRAIN_LUA =
   'local projected = { steerId = item.steerId, text = item.text, createdAt = item.createdAt } ' +
   'if item.clientSteerId then projected.clientSteerId = item.clientSteerId end ' +
   'if item.files then projected.files = item.files end ' +
+  'if item.quotes then projected.quotes = item.quotes end ' +
   'if item.preempt then projected.preempt = item.preempt end ' +
   'if item.preemptRevision then projected.preemptRevision = item.preemptRevision end ' +
   'currentProjected[#currentProjected + 1] = projected end ' +
@@ -4602,6 +4621,10 @@ export class RedisJobStore implements IJobStoreV2 {
        *  `preemptArmed: false` and silently degrade interrupt-steer to
        *  tool-boundary steering in EVERY Redis deployment. */
       preemptCapable: data.preemptCapable != null ? data.preemptCapable === '1' : undefined,
+      /** Same explicit-mapper trap as `preemptCapable`: without this line every
+       *  Redis read reports the owner quote-incapable, so admission would drop
+       *  all steer quotes (and their echo) in EVERY Redis deployment. */
+      steerQuotesExecutionId: data.steerQuotesExecutionId || undefined,
       providerAbortReady:
         data.providerAbortReady != null ? data.providerAbortReady === '1' : undefined,
       providerExecutionId: data.providerExecutionId || undefined,
diff --git a/packages/api/src/stream/interfaces/IJobStore.ts b/packages/api/src/stream/interfaces/IJobStore.ts
index ed1d5f44ca6..59090aa887f 100644
--- a/packages/api/src/stream/interfaces/IJobStore.ts
+++ b/packages/api/src/stream/interfaces/IJobStore.ts
@@ -167,6 +167,24 @@ export interface SerializableJobData {
    * preempt shipped, which reads as incapable: the honest outcome.
    */
   preemptCapable?: boolean;
+  /**
+   * Transient owner assertion that this replica's drain merges
+   * `SteerQueueItem.quotes` into the injected turn. Never stored as-is:
+   * createJob and `ApprovalLifecycle.resolve` translate it into
+   * `steerQuotesExecutionId` bound to the asserting owner's execution.
+   */
+  steerQuotesCapable?: boolean;
+  /**
+   * The `providerExecutionId` of the owner that asserted quote capability.
+   * Valid only while it equals the LIVE `providerExecutionId`: a legacy
+   * replica winning a HITL resume rewrites the execution id but cannot know
+   * this field, so its stale assertion self-invalidates — which a bare
+   * boolean could not do (an old resume patch omits rather than clears it).
+   * The fenced enqueue evaluates the equality atomically and strips
+   * `item.quotes` on mismatch, keeping the persisted item and the
+   * `quotesAccepted` echo honest; the client re-stages dropped excerpts.
+   */
+  steerQuotesExecutionId?: string;
 
   /** Explicitly false until the provider-owning replica has installed its
    * generation-fenced abort subscription. Missing is conservative legacy
@@ -383,6 +401,8 @@ export type JobMetadataPatch = Partial<
     | 'discoveredTools'
     | 'activityPhaseSnapshot'
     | 'preemptCapable'
+    | 'steerQuotesCapable'
+    | 'steerQuotesExecutionId'
     | 'providerExecutionId'
     | 'providerDrained'
     | 'generationProtocolVersion'
@@ -427,6 +447,10 @@ export interface SteerQueueItem {
    *  drain re-fetches each file by id scoped to the run's user and encodes
    *  fresh, so nothing here is trusted beyond identifying the file. */
   files?: Partial<TFile>[];
+  /** Quoted excerpts steered with the message, normalized at admission
+   *  (`getReferencedQuotes`). Kept separate from `text` so the persisted
+   *  steer part stays clean; merged into the model-bound turn at injection. */
+  quotes?: string[];
   /** The steer asked to seal the live model stream at the next provider-safe
    *  boundary instead of waiting for a tool step. Durable so a parked,
    *  claimed, or replayed chip keeps its "interrupting" label. */
@@ -442,7 +466,16 @@ export interface SteerQueueItem {
  * the same instruction twice after drain, terminal cleanup, or replacement. */
 export interface SteerReceipt {
   clientSteerId: string;
+  /** Quote-INDEPENDENT content hash (text/files/preempt) — the one shape every
+   * replica version computes, so lost-ACK retries replay across a rolling
+   * deploy in both directions. */
   fingerprint: string;
+  /** Identity of the REQUESTED quotes (pre any owner-capability strip),
+   * recorded beside the fingerprint so quote-aware readers enforce quote
+   * identity without making the fingerprint unreadable to legacy admission.
+   * Absent on receipts written by pre-quotes replicas or for quote-less
+   * requests. */
+  requestedQuotesFingerprint?: string;
   userId: string;
   tenantId?: string;
   agentId?: string;
diff --git a/packages/api/src/stream/metadata.ts b/packages/api/src/stream/metadata.ts
index d7aade47832..259af3b7cea 100644
--- a/packages/api/src/stream/metadata.ts
+++ b/packages/api/src/stream/metadata.ts
@@ -63,6 +63,9 @@ export function sanitizeJobMetadata(metadata: Partial<GenerationJobMetadata>): J
   if (metadata.preemptCapable !== undefined) {
     patch.preemptCapable = metadata.preemptCapable;
   }
+  if (metadata.steerQuotesCapable !== undefined) {
+    patch.steerQuotesCapable = metadata.steerQuotesCapable;
+  }
   if (metadata.generationProtocolVersion === 1 || metadata.generationProtocolVersion === 2) {
     patch.generationProtocolVersion = metadata.generationProtocolVersion;
   }
diff --git a/packages/api/src/types/stream.ts b/packages/api/src/types/stream.ts
index d588636c6f0..8f5423ce9d5 100644
--- a/packages/api/src/types/stream.ts
+++ b/packages/api/src/types/stream.ts
@@ -65,6 +65,10 @@ export interface GenerationJobMetadata {
   activityPhaseSnapshot?: ActivityPhaseSnapshot;
   /** See `SerializableJobData.preemptCapable`. */
   preemptCapable?: boolean;
+  /** See `SerializableJobData.steerQuotesCapable`. */
+  steerQuotesCapable?: boolean;
+  /** See `SerializableJobData.steerQuotesExecutionId`. */
+  steerQuotesExecutionId?: string;
   /** Exact provider segment whose completion gates destructive user cleanup. */
   providerExecutionId?: string;
   /** False only while that exact provider segment can still mutate user data. */
diff --git a/packages/data-provider/src/types/assistants.ts b/packages/data-provider/src/types/assistants.ts
index 5488229e67f..97752e545bd 100644
--- a/packages/data-provider/src/types/assistants.ts
+++ b/packages/data-provider/src/types/assistants.ts
@@ -687,6 +687,10 @@ export type SteerContentPart = {
   /** Attachments steered with the message; re-encoded per turn on replay
    *  like any other user-message media (refs only, never encoded data). */
   files?: Partial<TFile>[];
+  /** Quoted excerpts steered with the message, persisted separately from the
+   *  typed text (mirroring `TMessage.quotes`) so the UI renders them as
+   *  reference blocks; merged into the model-bound user turn on every replay. */
+  quotes?: string[];
 };
 
 export type TMessageContentParts =
diff --git a/packages/data-provider/src/types/runs.ts b/packages/data-provider/src/types/runs.ts
index a3ffd26ddac..5922b2ecc5d 100644
--- a/packages/data-provider/src/types/runs.ts
+++ b/packages/data-provider/src/types/runs.ts
@@ -201,6 +201,9 @@ export type TPendingSteer = {
   text: string;
   createdAt?: number;
   files?: Partial<TFile>[];
+  /** Quoted excerpts steered with the message ("Add to chat" selections);
+   *  merged into the model-bound text at the injection boundary. */
+  quotes?: string[];
   /** The steer asked to interrupt generation at the next safe boundary —
    *  kept on parked/replayed chips so the "interrupting" label survives. */
   preempt?: boolean;
@@ -222,6 +225,9 @@ export type TSteerAppliedEvent = {
     clientSteerId?: string;
     createdAt?: number;
     files?: Partial<TFile>[];
+    /** Quoted excerpts steered with the message (mirrors `SteerContentPart`,
+     *  which cannot be imported here without a module cycle). */
+    quotes?: string[];
   };
   responseMessageId?: string;
   conversationId?: string;