diff --git a/apps/cli/src/backends/gemini/runGemini.ts b/apps/cli/src/backends/gemini/runGemini.ts
index 0f9529ebba..86e0f4c664 100644
--- a/apps/cli/src/backends/gemini/runGemini.ts
+++ b/apps/cli/src/backends/gemini/runGemini.ts
@@ -74,10 +74,9 @@ import {
 import { maybeUpdateGeminiSessionIdMetadata } from '@/backends/gemini/utils/geminiSessionIdMetadata';
 import { updateMetadataBestEffort } from '@/api/session/sessionWritesBestEffort';
 import {
-  parseOptionsFromText,
-  hasIncompleteOptions,
+  segmentTrailingOptions,
   formatOptionsXml,
-} from '@/backends/gemini/utils/optionsParser';
+} from '@/utils/optionsParser';
 import { ConversationHistory } from '@/backends/gemini/utils/conversationHistory';
 import { createGeminiBackendMessageHandler } from '@/backends/gemini/runtime/createGeminiBackendMessageHandler';
 import { reportGeminiConnectedServiceRuntimeAuthFailureBestEffort } from '@/backends/gemini/connectedServices/surfaceGeminiConnectedServiceRuntimeAuthFailure';
@@ -983,7 +982,11 @@ export async function runGemini(opts: {
         // Send accumulated response to mobile app ONLY when turn is complete
         // This prevents message fragmentation from Gemini's chunked responses
         if (hasAssistantOutput) {
-          const { text: messageText, options } = parseOptionsFromText(turnMessageState.accumulatedResponse);
+          const { before, options, hasIncompleteTrailingOptions } = segmentTrailingOptions(turnMessageState.accumulatedResponse);
+          // Trim the app-facing message (Gemini display concern) to stay
+          // byte-identical to the previous parseOptionsFromText behavior; the
+          // terminal formatter path preserves surrounding whitespace verbatim.
+          const messageText = before.trim();
           
           // Record assistant response in conversation history for context preservation
           conversationHistory.addAssistantMessage(messageText);
@@ -994,7 +997,7 @@ export async function runGemini(opts: {
             const optionsXml = formatOptionsXml(options);
             finalMessageText = messageText + optionsXml;
             logger.debug(`[gemini] Found ${options.length} options in response`);
-          } else if (hasIncompleteOptions(turnMessageState.accumulatedResponse)) {
+          } else if (hasIncompleteTrailingOptions) {
             logger.debug(`[gemini] Warning: Incomplete options block detected`);
           }
           
diff --git a/apps/cli/src/backends/gemini/utils/optionsParser.ts b/apps/cli/src/backends/gemini/utils/optionsParser.ts
deleted file mode 100644
index bf105dd1f8..0000000000
--- a/apps/cli/src/backends/gemini/utils/optionsParser.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Options Parser Utilities
- * 
- * Utilities for parsing and formatting XML options blocks from agent responses.
- * Used for extracting and formatting <options><option>...</option></options> blocks.
- */
-
-/**
- * Check if text has an incomplete options block (opening tag but no closing tag)
- * 
- * @param text - The text to check
- * @returns true if there's an opening <options> tag without a closing </options> tag
- */
-export function hasIncompleteOptions(text: string): boolean {
-  const hasOpeningTag = /<options>/i.test(text);
-  const hasClosingTag = /<\/options>/i.test(text);
-  return hasOpeningTag && !hasClosingTag;
-}
-
-/**
- * Parse XML options from text
- * Extracts <options><option>...</option></options> blocks and returns
- * the text without options and the parsed options array
- * 
- * @param text - The text containing options XML
- * @returns Object with text (without options) and options array
- */
-export function parseOptionsFromText(text: string): { text: string; options: string[] } {
-  // Match <options>...</options> block (multiline, non-greedy)
-  const optionsRegex = /<options>\s*([\s\S]*?)\s*<\/options>/i;
-  const match = text.match(optionsRegex);
-  
-  if (!match) {
-    return { text: text.trim(), options: [] };
-  }
-  
-  // Extract options block content
-  const optionsBlock = match[1];
-  
-  // Parse individual <option> tags
-  const optionRegex = /<option>(.*?)<\/option>/gi;
-  const options: string[] = [];
-  let optionMatch;
-  
-  while ((optionMatch = optionRegex.exec(optionsBlock)) !== null) {
-    const optionText = optionMatch[1].trim();
-    if (optionText) {
-      options.push(optionText);
-    }
-  }
-  
-  // Remove options block from text
-  const textWithoutOptions = text.replace(optionsRegex, '').trim();
-  
-  return { text: textWithoutOptions, options };
-}
-
-/**
- * Format options array as XML string
- * 
- * @param options - Array of option strings
- * @returns XML formatted string with <options> block
- */
-export function formatOptionsXml(options: string[]): string {
-  if (options.length === 0) {
-    return '';
-  }
-  return '\n<options>\n' + options.map(opt => `    <option>${opt}</option>`).join('\n') + '\n</options>';
-}
-
diff --git a/apps/cli/src/ui/messageFormatterInk.test.ts b/apps/cli/src/ui/messageFormatterInk.test.ts
new file mode 100644
index 0000000000..5b3aff657c
--- /dev/null
+++ b/apps/cli/src/ui/messageFormatterInk.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+import type { SDKAssistantMessage, SDKMessage, SDKResultMessage } from '@/backends/claude/sdk'
+import { MessageBuffer } from './ink/messageBuffer'
+import { formatClaudeMessageForInk } from './messageFormatterInk'
+
+function buildAssistantMessage(text: string): SDKMessage {
+    return {
+        type: 'assistant',
+        message: {
+            role: 'assistant',
+            content: [{ type: 'text', text }],
+        },
+    } satisfies SDKAssistantMessage
+}
+
+function buildAssistantMessageFromTextBlocks(...texts: string[]): SDKMessage {
+    return {
+        type: 'assistant',
+        message: {
+            role: 'assistant',
+            content: texts.map((text) => ({ type: 'text', text })),
+        },
+    } satisfies SDKAssistantMessage
+}
+
+describe('formatClaudeMessageForInk', () => {
+    it('renders assistant <options> blocks as a numbered list instead of raw XML', () => {
+        const messageBuffer = new MessageBuffer()
+        const text = 'Should I proceed?\n\n<options>\n    <option>Yes, go ahead</option>\n    <option>No, stop here</option>\n</options>'
+
+        formatClaudeMessageForInk(buildAssistantMessage(text), messageBuffer)
+
+        const contents = messageBuffer.getMessages().map((m) => m.content)
+        expect(contents).toContain('Should I proceed?\n\nOptions:\n  1. Yes, go ahead\n  2. No, stop here')
+        expect(contents.join('\n')).not.toContain('<options>')
+    })
+
+    it('leaves assistant text without options untouched', () => {
+        const messageBuffer = new MessageBuffer()
+        const text = 'All done. Nothing to choose here.'
+
+        formatClaudeMessageForInk(buildAssistantMessage(text), messageBuffer)
+
+        const contents = messageBuffer.getMessages().map((m) => m.content)
+        expect(contents).toContain(text)
+    })
+
+    it('assembles an options block split across two adjacent text blocks', () => {
+        const messageBuffer = new MessageBuffer()
+        const message = buildAssistantMessageFromTextBlocks(
+            'Should I proceed?\n\n<options>\n<option>Yes, go ahead</option>\n',
+            '<option>No, stop here</option>\n</options>',
+        )
+
+        formatClaudeMessageForInk(message, messageBuffer)
+
+        const contents = messageBuffer.getMessages().map((m) => m.content)
+        expect(contents).toContain('Should I proceed?\n\nOptions:\n  1. Yes, go ahead\n  2. No, stop here')
+        expect(contents.join('\n')).not.toContain('<options>')
+        expect(contents.join('\n')).not.toContain('<option>')
+    })
+
+    it('renders <options> blocks in the result summary as a numbered list', () => {
+        const messageBuffer = new MessageBuffer()
+        const resultMessage = {
+            type: 'result',
+            subtype: 'success',
+            result: 'Pick a next step.\n\n<options>\n<option>Continue</option>\n<option>Abort</option>\n</options>',
+        } as unknown as SDKResultMessage
+
+        formatClaudeMessageForInk(resultMessage, messageBuffer)
+
+        const contents = messageBuffer.getMessages().map((m) => m.content)
+        expect(contents).toContain('Pick a next step.\n\nOptions:\n  1. Continue\n  2. Abort')
+        expect(contents.join('\n')).not.toContain('<options>')
+    })
+})
diff --git a/apps/cli/src/ui/messageFormatterInk.ts b/apps/cli/src/ui/messageFormatterInk.ts
index 4a13bc7b85..7109892441 100644
--- a/apps/cli/src/ui/messageFormatterInk.ts
+++ b/apps/cli/src/ui/messageFormatterInk.ts
@@ -1,4 +1,5 @@
 import type { SDKMessage, SDKAssistantMessage, SDKResultMessage, SDKSystemMessage, SDKUserMessage } from '@/backends/claude/sdk'
+import { formatTextWithOptionsForTerminal } from '@/utils/optionsParser'
 import type { MessageBuffer } from './ink/messageBuffer'
 import { logger } from './logger'
 
@@ -69,11 +70,31 @@ export function formatClaudeMessageForInk(
             const assistantMsg = message as SDKAssistantMessage
             if (assistantMsg.message && assistantMsg.message.content) {
                 messageBuffer.addMessage('🤖 Assistant:', 'assistant')
-                
+
+                // Options can be split across adjacent SDK text blocks (the model
+                // streams one logical message as several contiguous text
+                // fragments). Assemble each contiguous run of text blocks into one
+                // string and format it ONCE so a trailing <options> block that
+                // spans the block boundary is still recognised. Flush the run on
+                // any non-text block or at the end of the content array.
+                let textRun = ''
+                let hasTextRun = false
+                const flushTextRun = (): void => {
+                    if (hasTextRun) {
+                        messageBuffer.addMessage(formatTextWithOptionsForTerminal(textRun), 'assistant')
+                        textRun = ''
+                        hasTextRun = false
+                    }
+                }
+
                 for (const block of assistantMsg.message.content) {
                     if (block.type === 'text') {
-                        messageBuffer.addMessage(block.text || '', 'assistant')
+                        // Join with '' since SDK text blocks are already contiguous
+                        // fragments of the raw stream.
+                        textRun += block.text || ''
+                        hasTextRun = true
                     } else if (block.type === 'tool_use') {
+                        flushTextRun()
                         messageBuffer.addMessage(`🔧 Tool: ${block.name}`, 'tool')
                         if (block.input) {
                             const inputStr = JSON.stringify(block.input, null, 2)
@@ -84,8 +105,11 @@ export function formatClaudeMessageForInk(
                                 messageBuffer.addMessage(`Input: ${inputStr}`, 'tool')
                             }
                         }
+                    } else {
+                        flushTextRun()
                     }
                 }
+                flushTextRun()
             }
             break
         }
@@ -95,7 +119,7 @@ export function formatClaudeMessageForInk(
             if (resultMsg.subtype === 'success') {
                 if ('result' in resultMsg && resultMsg.result) {
                     messageBuffer.addMessage('✨ Summary:', 'result')
-                    messageBuffer.addMessage(resultMsg.result || '', 'result')
+                    messageBuffer.addMessage(formatTextWithOptionsForTerminal(resultMsg.result || ''), 'result')
                 }
                 
                 if (resultMsg.usage) {
diff --git a/apps/cli/src/utils/optionsParser.test.ts b/apps/cli/src/utils/optionsParser.test.ts
new file mode 100644
index 0000000000..2a7c9af00f
--- /dev/null
+++ b/apps/cli/src/utils/optionsParser.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+import {
+    formatOptionsXml,
+    formatTextWithOptionsForTerminal,
+    segmentTrailingOptions,
+} from './optionsParser';
+
+describe('segmentTrailingOptions', () => {
+    it('splits a trailing options block from the preceding prose', () => {
+        const input = 'Which approach do you prefer?\n\n<options>\n    <option>Option A</option>\n    <option>Option B</option>\n</options>';
+        const result = segmentTrailingOptions(input);
+        expect(result.before).toBe('Which approach do you prefer?\n\n');
+        expect(result.options).toEqual(['Option A', 'Option B']);
+        expect(result.hasIncompleteTrailingOptions).toBe(false);
+    });
+
+    it('preserves surrounding whitespace in before exactly (no trim)', () => {
+        const input = '  Leading and trailing spaces.  \n<options>\n<option>Yes</option>\n</options>';
+        const result = segmentTrailingOptions(input);
+        expect(result.before).toBe('  Leading and trailing spaces.  \n');
+    });
+
+    it('returns the full text as before when there is no options block', () => {
+        const input = '  Just a plain answer.  ';
+        const result = segmentTrailingOptions(input);
+        expect(result.before).toBe(input);
+        expect(result.options).toEqual([]);
+        expect(result.hasIncompleteTrailingOptions).toBe(false);
+    });
+
+    it('matches tags case-insensitively', () => {
+        const input = 'Pick one:\n<OPTIONS>\n<OPTION>Yes</OPTION>\n<OPTION>No</OPTION>\n</OPTIONS>';
+        const result = segmentTrailingOptions(input);
+        expect(result.before).toBe('Pick one:\n');
+        expect(result.options).toEqual(['Yes', 'No']);
+    });
+
+    it('ignores empty option tags', () => {
+        const input = '<options><option></option><option>Keep me</option></options>';
+        const result = segmentTrailingOptions(input);
+        expect(result.options).toEqual(['Keep me']);
+    });
+
+    it('does NOT match an <options> block that is not at the end of the text', () => {
+        const input = 'See <options><option>A</option></options> then more prose follows.';
+        const result = segmentTrailingOptions(input);
+        expect(result.before).toBe(input);
+        expect(result.options).toEqual([]);
+        expect(result.hasIncompleteTrailingOptions).toBe(false);
+    });
+
+    it('flags an unclosed trailing options block as incomplete', () => {
+        const result = segmentTrailingOptions('Question?\n<options>\n<option>Yes</option>');
+        expect(result.hasIncompleteTrailingOptions).toBe(true);
+        expect(result.options).toEqual([]);
+        expect(result.before).toBe('Question?\n<options>\n<option>Yes</option>');
+    });
+
+    it('only segments the LAST/trailing block when several appear', () => {
+        const input = 'Literal <options><option>X</option></options> in prose.\n<options>\n<option>Real</option>\n</options>';
+        const result = segmentTrailingOptions(input);
+        expect(result.before).toBe('Literal <options><option>X</option></options> in prose.\n');
+        expect(result.options).toEqual(['Real']);
+    });
+});
+
+describe('formatOptionsXml', () => {
+    it('round-trips options through XML', () => {
+        const xml = formatOptionsXml(['One', 'Two']);
+        expect(segmentTrailingOptions(xml).options).toEqual(['One', 'Two']);
+    });
+
+    it('returns an empty string for no options', () => {
+        expect(formatOptionsXml([])).toBe('');
+    });
+});
+
+describe('formatTextWithOptionsForTerminal', () => {
+    it('replaces a trailing options block with a numbered list', () => {
+        const input = 'Which approach do you prefer?\n\n<options>\n    <option>Option A</option>\n    <option>Option B</option>\n</options>';
+        const result = formatTextWithOptionsForTerminal(input);
+        expect(result).toBe('Which approach do you prefer?\n\nOptions:\n  1. Option A\n  2. Option B');
+        expect(result).not.toContain('<options>');
+    });
+
+    it('renders a numbered list when the message is options-only', () => {
+        const input = '<options>\n<option>Yes</option>\n<option>No</option>\n</options>';
+        expect(formatTextWithOptionsForTerminal(input)).toBe('Options:\n  1. Yes\n  2. No');
+    });
+
+    it('returns text unchanged when there is no options block (exact equality)', () => {
+        const input = 'Plain answer with  spacing\npreserved.';
+        expect(formatTextWithOptionsForTerminal(input)).toBe(input);
+    });
+
+    it('preserves leading and trailing whitespace of the prose exactly', () => {
+        const input = '\n\n  Choose:  \n<options>\n<option>A</option>\n<option>B</option>\n</options>';
+        expect(formatTextWithOptionsForTerminal(input)).toBe('\n\n  Choose:  \nOptions:\n  1. A\n  2. B');
+    });
+
+    it('leaves a fenced/literal <options> block in the MIDDLE of text untouched', () => {
+        const input = 'Here is how the markup looks:\n```xml\n<options>\n<option>A</option>\n<option>B</option>\n</options>\n```\nThat is the format.';
+        expect(formatTextWithOptionsForTerminal(input)).toBe(input);
+    });
+
+    it('leaves a literal <options> block untouched when prose follows it', () => {
+        const input = 'The tag <options><option>A</option></options> is used for menus, note the syntax.';
+        expect(formatTextWithOptionsForTerminal(input)).toBe(input);
+    });
+
+    it('renders only the LAST block, leaving earlier literal ones raw', () => {
+        const input = 'Example markup: <options><option>X</option></options>\nNow pick one:\n<options>\n<option>Real A</option>\n<option>Real B</option>\n</options>';
+        const result = formatTextWithOptionsForTerminal(input);
+        expect(result).toBe('Example markup: <options><option>X</option></options>\nNow pick one:\nOptions:\n  1. Real A\n  2. Real B');
+        // The earlier literal block is preserved verbatim.
+        expect(result).toContain('<options><option>X</option></options>');
+        // Only one block was rendered as a list.
+        expect(result.match(/Options:/g)?.length).toBe(1);
+    });
+
+    it('drops an empty trailing options block, preserving before exactly', () => {
+        const input = 'Before the empty block\n<options>\n</options>';
+        expect(formatTextWithOptionsForTerminal(input)).toBe('Before the empty block\n');
+    });
+
+    it('returns text unchanged for an incomplete (unclosed) trailing block', () => {
+        const input = 'Question?\n<options>\n<option>Yes</option>';
+        expect(formatTextWithOptionsForTerminal(input)).toBe(input);
+    });
+});
diff --git a/apps/cli/src/utils/optionsParser.ts b/apps/cli/src/utils/optionsParser.ts
new file mode 100644
index 0000000000..7f1104487c
--- /dev/null
+++ b/apps/cli/src/utils/optionsParser.ts
@@ -0,0 +1,137 @@
+/**
+ * Options Parser Utilities
+ * 
+ * Utilities for parsing and formatting XML options blocks from agent responses.
+ * Used for extracting and formatting <options><option>...</option></options> blocks.
+ */
+
+/**
+ * Single regex owning the <option> item grammar, shared by every consumer so the
+ * terminal formatter and the Gemini adapter never diverge.
+ * Matches one <option>...</option> pair (case-insensitive, non-greedy inner).
+ */
+const OPTION_ITEM_REGEX = /<option>(.*?)<\/option>/gi;
+
+/**
+ * Regex owning the TRAILING options-block grammar. Anchored to the END of the
+ * string (allowing whitespace after </options>), case-insensitive on tags, with
+ * a non-greedy inner (which never spans a nested <options> opener, so the block
+ * begins at the LAST opener) and tolerated whitespace around that inner. This
+ * is the sole matcher for a turn-final options block; literal or fenced
+ * <options> markup appearing earlier in the text is intentionally NOT matched.
+ */
+const TRAILING_OPTIONS_BLOCK_REGEX = /<options>\s*((?:(?!<options>)[\s\S])*?)\s*<\/options>\s*$/i;
+
+/**
+ * Parse the non-empty <option> texts out of an options-block inner string.
+ * 
+ * @param inner - The inner content between <options> and </options>
+ * @returns Array of trimmed, non-empty option strings (empty tags dropped)
+ */
+function parseOptionItems(inner: string): string[] {
+  const options: string[] = [];
+  let optionMatch: RegExpExecArray | null;
+  OPTION_ITEM_REGEX.lastIndex = 0;
+  while ((optionMatch = OPTION_ITEM_REGEX.exec(inner)) !== null) {
+    const optionText = optionMatch[1].trim();
+    if (optionText) {
+      options.push(optionText);
+    }
+  }
+  return options;
+}
+
+/**
+ * Detect a still-streaming (unclosed) trailing options block: the LAST
+ * <options> opener in `text` has no matching </options> after it.
+ * 
+ * @param text - The text to inspect
+ * @returns true when the final <options> opener is not yet closed
+ */
+function hasUnclosedTrailingOptions(text: string): boolean {
+  const openRegex = /<options>/gi;
+  let lastOpenEnd = -1;
+  let openMatch: RegExpExecArray | null;
+  while ((openMatch = openRegex.exec(text)) !== null) {
+    lastOpenEnd = openMatch.index + openMatch[0].length;
+  }
+  if (lastOpenEnd === -1) {
+    return false;
+  }
+  return !/<\/options>/i.test(text.slice(lastOpenEnd));
+}
+
+/**
+ * Canonical trailing-options segmenter — the sole owner of the options-block
+ * grammar, reused by the terminal formatter AND the Gemini adapter.
+ *
+ * Splits `text` into the prose BEFORE a turn-final <options> block and the
+ * parsed option list, WITHOUT mutating any surrounding whitespace. Only a
+ * <options>...</options> block anchored to the END of `text` (optionally
+ * followed by trailing whitespace) is recognised; literal or fenced <options>
+ * markup appearing mid-text stays part of `before`, untouched.
+ *
+ * @param text - The full assistant/turn text to segment
+ * @returns before (verbatim prose preceding the block, or the full text when no
+ *   trailing block matched), options (non-empty trimmed option strings), and
+ *   hasIncompleteTrailingOptions (true only for a trailing opener with no closer)
+ */
+export function segmentTrailingOptions(text: string): {
+  before: string;
+  options: string[];
+  hasIncompleteTrailingOptions: boolean;
+} {
+  const match = text.match(TRAILING_OPTIONS_BLOCK_REGEX);
+  if (!match) {
+    return {
+      before: text,
+      options: [],
+      hasIncompleteTrailingOptions: hasUnclosedTrailingOptions(text),
+    };
+  }
+  const before = text.slice(0, match.index);
+  const options = parseOptionItems(match[1]);
+  return { before, options, hasIncompleteTrailingOptions: false };
+}
+
+/**
+ * Format options array as XML string
+ * 
+ * @param options - Array of option strings
+ * @returns XML formatted string with <options> block
+ */
+export function formatOptionsXml(options: string[]): string {
+  if (options.length === 0) {
+    return '';
+  }
+  return '\n<options>\n' + options.map(opt => `    <option>${opt}</option>`).join('\n') + '\n</options>';
+}
+
+/**
+ * Format assistant text for terminal display.
+ * Replaces ONLY a turn-final <options>...</options> block with a readable
+ * numbered list so terminal surfaces (which have no tappable option buttons) do
+ * not show raw XML. Everything before the block — including all whitespace — is
+ * preserved verbatim; the only span that changes is the trailing options block.
+ * Literal or fenced <options> markup earlier in the text is left untouched, and
+ * a still-streaming (unclosed) trailing block passes through unchanged.
+ *
+ * @param text - The assistant text potentially ending in an options XML block
+ * @returns The text with a trailing options block rendered as a numbered list
+ */
+export function formatTextWithOptionsForTerminal(text: string): string {
+  const { before, options, hasIncompleteTrailingOptions } = segmentTrailingOptions(text);
+  if (hasIncompleteTrailingOptions) {
+    // Don't rewrite a block that is still streaming in.
+    return text;
+  }
+  if (options.length === 0) {
+    // No trailing block (before === text) or a trailing block with no non-empty
+    // options (before drops the empty block); either way return before verbatim.
+    return before;
+  }
+  const numberedList = options
+    .map((option, index) => `  ${index + 1}. ${option}`)
+    .join('\n');
+  return `${before}Options:\n${numberedList}`;
+}