diff --git a/package.json b/package.json
index 25511df7e..062324ebf 100644
--- a/package.json
+++ b/package.json
@@ -5,8 +5,9 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "test": "npm run test:systemone && npm run test:systemone:fast && node --test test/browser-dialogs.mjs && npm run test:firefox-bidi && npm run test:runtime-lifecycle && npm run test:provider-limits && npm run test:accessibility-tree-benchmark && npm run test:toolbar-guard && npm run test:pdf-read && npm run test:pdf-selection && npm run test:social-contract && npm run test:safesocial && npm run test:build-unpacked && npm run test:attachment-drop && node test/run.js && node test/selection-scope-restoration.mjs && node scripts/benchmark-offline-relevance.mjs && npm run test:security",
+    "test": "npm run test:markdown && npm run test:systemone && npm run test:systemone:fast && node --test test/browser-dialogs.mjs && npm run test:firefox-bidi && npm run test:runtime-lifecycle && npm run test:provider-limits && npm run test:accessibility-tree-benchmark && npm run test:toolbar-guard && npm run test:pdf-read && npm run test:pdf-selection && npm run test:social-contract && npm run test:safesocial && npm run test:build-unpacked && npm run test:attachment-drop && node test/run.js && node test/selection-scope-restoration.mjs && node scripts/benchmark-offline-relevance.mjs && npm run test:security",
     "test:provider-limits": "node test/provider-model-limits.mjs",
+    "test:markdown": "node --test test/markdown-render.mjs",
     "test:accessibility-tree-benchmark": "node --test test/llm/lib/accessibility-tree-formats.test.mjs && node test/llm/accessibility-tree-benchmark.mjs --no-exact-tokenizer --check",
     "test:attachment-drop": "node test/attachment-drop.mjs",
     "test:security": "node test/security/injection-corpus.mjs",
diff --git a/src/chrome/src/ui/history-text.js b/src/chrome/src/ui/history-text.js
index 074daadec..c72b3b6d6 100644
--- a/src/chrome/src/ui/history-text.js
+++ b/src/chrome/src/ui/history-text.js
@@ -125,10 +125,23 @@ export function historyTextFromElement(root, { markdown = true } = {}) {
     if (markdown && tagName === 'PRE') {
       const language = String(node.parentElement?.querySelector?.('.code-lang')?.textContent || '').trim();
       ensureBreak();
-      output += `\`\`\`${language}\n`;
+      const beforeCode = output;
+      output = '';
       for (const child of Array.from(node.childNodes || [])) visit(child, false, true);
       ensureBreak();
-      output += '```';
+      const code = output;
+      // History must not reintroduce ambiguous fences around a Markdown
+      // document (or any code sample containing literal backtick runs).
+      const fenceCharacter = language.includes('`') ? '~' : '`';
+      let fenceLength = 3;
+      for (const match of code.matchAll(new RegExp(`${fenceCharacter}{3,}`, 'g'))) {
+        fenceLength = Math.max(fenceLength, match[0].length + 1);
+      }
+      const fence = fenceCharacter.repeat(fenceLength);
+      // Keep an info string separate from the fence so a label beginning with
+      // the same marker cannot extend the opener past its matching closer.
+      const info = language ? ` ${language}` : '';
+      output = `${beforeCode}${fence}${info}\n${code}${fence}`;
       return;
     }
     if (markdown && tagName === 'CODE' && !inPre) {
diff --git a/src/chrome/src/ui/markdown-render.js b/src/chrome/src/ui/markdown-render.js
index f8aa7a878..8fb55931d 100644
--- a/src/chrome/src/ui/markdown-render.js
+++ b/src/chrome/src/ui/markdown-render.js
@@ -18,6 +18,7 @@ const LANGUAGE_ALIASES = Object.freeze({
   go: 'clike', rust: 'clike', rs: 'clike', swift: 'clike',
   php: 'clike', ruby: 'clike', rb: 'clike',
 });
+const INTERRUPTING_HTML_BLOCK_TAGS = new Set(('address article aside base basefont blockquote body caption center col colgroup dd details dialog dir div dl dt fieldset figcaption figure footer form frame frameset h1 h2 h3 h4 h5 h6 head header hr html iframe legend li link main menu menuitem nav noframes ol optgroup option p param search section summary table tbody td tfoot th thead title tr track ul').split(' '));
 
 const JS_KEYWORDS = new Set(('abstract as async await break case catch class const continue debugger declare default delete do else enum export extends finally for from function get if implements import in infer instanceof interface keyof let namespace new of private protected public readonly return satisfies set static super switch throw try type typeof var void while with yield').split(' '));
 const JS_CONSTANTS = new Set(('true false null undefined NaN Infinity').split(' '));
@@ -57,6 +58,618 @@ export function codeFenceLanguage(infoString) {
   return String(infoString || '').trim().split(/\s+/, 1)[0] || '';
 }
 
+function fenceContainer(prefix, indentation = '') {
+  const source = String(prefix);
+  const quotePrefix = quotePrefixAt(source);
+  let remainder = source;
+  let listPrefix = '';
+  let quoteDepth = 0;
+  let overIndentedQuote = false;
+  let lastListMarkerWidth = 0;
+  let lastListPrefixWidth = 0;
+  const listIndentGroups = [0];
+  while (remainder) {
+    const containerStartColumn = indentationColumns(source.slice(0, source.length - remainder.length));
+    // Preserve a deeply indented quote only long enough to resolve a
+    // continuation from an enclosing list; it is never a container itself.
+    const quote = quoteMarkerAt(remainder, containerStartColumn, true);
+    if (quote) {
+      quoteDepth += 1;
+      overIndentedQuote ||= quote.overIndented;
+      listIndentGroups.push(0);
+      remainder = remainder.slice(quote.length);
+      continue;
+    }
+    const list = listPrefixAt(remainder, containerStartColumn);
+    if (!list) break;
+    listPrefix += list;
+    lastListPrefixWidth = indentationColumnsAt(list, containerStartColumn) - containerStartColumn;
+    lastListMarkerWidth = indentationColumnsAt(list.replace(/[ \t]+$/, ''), containerStartColumn) - containerStartColumn;
+    const implicitListPadding = !/[ \t]$/.test(list) && remainder === list ? 1 : 0;
+    listIndentGroups[listIndentGroups.length - 1] += indentationColumnsAt(list, containerStartColumn) - containerStartColumn
+      + implicitListPadding;
+    remainder = remainder.slice(list.length);
+  }
+  return {
+    containerPrefix: source.slice(0, source.length - remainder.length),
+    quotePrefix,
+    quoteDepth,
+    listPrefix,
+    lastListMarkerWidth,
+    lastListPrefixWidth,
+    listIndentGroups,
+    overIndentedQuote,
+    leadingQuoteIndent: indentationColumns(source.match(/^[ \t]*(?=>)/)?.[0] || ''),
+    rawPrefix: source,
+    indentation: String(indentation),
+  };
+}
+
+function indentationColumnsAt(value, startColumn = 0) {
+  let columns = startColumn;
+  for (const character of String(value)) {
+    columns += character === '\t' ? 4 - (columns % 4) : 1;
+  }
+  return columns;
+}
+
+function indentationColumns(value) {
+  return indentationColumnsAt(value);
+}
+
+function listPrefixAt(value, startColumn = 0) {
+  const source = String(value);
+  const marker = source.match(/^[ \t]*(?:[-+*]|\d{1,9}[.)])/);
+  const leadingIndentation = marker?.[0].match(/^[ \t]*/)?.[0] || '';
+  const next = source[marker?.[0].length];
+  if (!marker
+    || indentationColumnsAt(leadingIndentation, startColumn) - startColumn > 3
+    || (next && !/^[ \t]$/.test(next))) return null;
+  let offset = marker[0].length;
+  let column = indentationColumnsAt(marker[0], startColumn);
+  let paddingColumns = 0;
+  while (/^[ \t]$/.test(value[offset] || '')) {
+    const width = value[offset] === '\t' ? 4 - (column % 4) : 1;
+    paddingColumns += width;
+    column += width;
+    offset += 1;
+  }
+  if (paddingColumns > 4 && source[marker[0].length] === '\t') {
+    return `${source.slice(0, marker[0].length)} `;
+  }
+  return source.slice(0, marker[0].length + (paddingColumns <= 4 ? offset - marker[0].length : 1));
+}
+
+function quoteMarkerAt(value, startColumn = 0, allowOverIndentation = false) {
+  let offset = 0;
+  let column = startColumn;
+  while (/^[ \t]$/.test(value[offset] || '')) {
+    const width = value[offset] === '\t' ? 4 - (column % 4) : 1;
+    if (!allowOverIndentation && column + width - startColumn > 3) break;
+    column += width;
+    offset += 1;
+  }
+  const marker = String(value).slice(offset).match(/^>[ \t]?/);
+  if (!marker) return null;
+  return {
+    length: offset + marker[0].length,
+    column: indentationColumnsAt(marker[0], column),
+    overIndented: column - startColumn > 3,
+  };
+}
+
+function quotePrefixAt(value, startColumn = 0) {
+  const source = String(value);
+  let offset = 0;
+  let column = startColumn;
+  while (offset < source.length) {
+    const quote = quoteMarkerAt(source.slice(offset), column);
+    if (!quote) break;
+    offset += quote.length;
+    column = quote.column;
+  }
+  return source.slice(0, offset);
+}
+
+function fenceIndentationColumns(container) {
+  const startColumn = indentationColumns(container.rawPrefix);
+  return indentationColumnsAt(container.indentation, startColumn) - startColumn;
+}
+
+function consumeIndentationColumns(line, columns, startColumn = 0) {
+  let offset = 0;
+  let consumed = 0;
+  let column = startColumn;
+  while (offset < line.length && consumed < columns && /^[ \t]$/.test(line[offset])) {
+    if (line[offset] === '\t') {
+      const tabWidth = 4 - (column % 4);
+      if (consumed + tabWidth > columns) {
+        return `${' '.repeat(consumed + tabWidth - columns)}${line.slice(offset + 1)}`;
+      }
+      consumed += tabWidth;
+      column += tabWidth;
+    } else {
+      consumed += 1;
+      column += 1;
+    }
+    offset += 1;
+  }
+  return consumed === columns ? line.slice(offset) : null;
+}
+
+function stripIndentationColumns(line, columns, startColumn = 0) {
+  const stripped = consumeIndentationColumns(line, columns, startColumn);
+  if (stripped != null) return stripped;
+  return String(line).replace(/^[ \t]*/, '');
+}
+
+function stripContainerPrefix(line, container) {
+  let remainder = String(line);
+  let column = 0;
+  for (let quoteIndex = 0; quoteIndex < container.quoteDepth; quoteIndex += 1) {
+    if (!remainder.trim()) return '';
+    const listIndent = container.listIndentGroups[quoteIndex];
+    remainder = consumeIndentationColumns(remainder, listIndent, column);
+    if (remainder == null) return null;
+    column += listIndent;
+    const quote = quoteMarkerAt(remainder, column);
+    if (!quote) return null;
+    column = quote.column;
+    remainder = remainder.slice(quote.length);
+  }
+  if (!remainder.trim()) return '';
+  return consumeIndentationColumns(remainder, container.listIndentGroups.at(-1), column);
+}
+
+function fenceIndentationInContainer(fence, container) {
+  const indentation = fenceIndentationColumns(fence);
+  if (fence.listPrefix) return indentation;
+  return Math.max(0, indentation - container.listIndentGroups.at(-1));
+}
+
+function fenceCloserInContainer(opener, candidate) {
+  if (!opener.quoteDepth && !opener.listPrefix) {
+    return !candidate.quoteDepth && !candidate.listPrefix
+      && indentationColumns(candidate.indentation) <= 3;
+  }
+  const remainder = stripContainerPrefix(`${candidate.rawPrefix}${candidate.indentation}x`, opener);
+  const extraIndentation = remainder?.slice(0, -1);
+  return remainder?.endsWith('x')
+    && /^[ \t]*$/.test(extraIndentation)
+    && indentationColumnsAt(extraIndentation, indentationColumns(opener.rawPrefix)) - indentationColumns(opener.rawPrefix) <= 3;
+}
+
+function isFenceCloser(opener, candidate, fence, info) {
+  return fenceCloserInContainer(opener.container, candidate)
+    && !info.trim()
+    && fence[0] === opener.fence[0]
+    && fence.length >= opener.fence.length;
+}
+
+function nestedFenceCloserIndex(matches, containers, closerIndexes, cache, startIndex, fence, container) {
+  const key = `${fence[0]}:${fence.length}:${container.quoteDepth}:${container.listIndentGroups.join(',')}`;
+  let compatible = cache.get(key);
+  if (!compatible) {
+    const nested = { fence, container };
+    compatible = (closerIndexes.get(fence[0]) || []).filter(index => (
+      isFenceCloser(nested, containers[index], matches[index].fence, matches[index].info)
+    ));
+    cache.set(key, compatible);
+  }
+  let low = 0;
+  let high = compatible.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (compatible[middle] <= startIndex) low = middle + 1;
+    else high = middle;
+  }
+  return low < compatible.length ? compatible[low] : -1;
+}
+
+function outerFenceCloserAfterNested(
+  source,
+  matches,
+  containers,
+  closerIndexes,
+  cache,
+  startIndex,
+  outer,
+  noListScanPositions,
+) {
+  for (let index = startIndex + 1; index < matches.length; index += 1) {
+    const match = matches[index];
+    const container = containers[index];
+    if (isFenceCloser(outer, container, match.fence, match.info)) return index;
+
+    const validOpening = match.fence[0] !== '`' || !match.info.includes('`');
+    if (!validOpening || !match.info.trim()) continue;
+    const nestedContainer = (fenceIndentationColumns(container) > 3 || container.leadingQuoteIndent > 3 || container.overIndentedQuote)
+      ? listContinuationContainer(source, match.index, match.prefix, match.indentation, noListScanPositions)
+      : container;
+    if (!nestedContainer) continue;
+    const nestedCloserIndex = nestedFenceCloserIndex(
+      matches,
+      containers,
+      closerIndexes,
+      cache,
+      index,
+      match.fence,
+      nestedContainer,
+    );
+    if (nestedCloserIndex >= 0) index = nestedCloserIndex;
+  }
+  return -1;
+}
+
+function startsInterruptingHtmlBlock(content) {
+  // CommonMark HTML block types 1–6 interrupt paragraphs; inline tags do not.
+  if (/^(?:<!--|<\?|<![A-Za-z]|<!\[CDATA\[|<(?:pre|script|style|textarea)(?=[ \t>]|$))/i.test(content)) return true;
+  const tag = content.match(/^<\/?([A-Za-z][A-Za-z0-9-]*)(?=[ \t>]|\/>|$)/);
+  return Boolean(tag && INTERRUPTING_HTML_BLOCK_TAGS.has(tag[1].toLowerCase()));
+}
+
+function listContinuationContainer(source, position, prefix, indentation, noListScanPositions) {
+  const current = fenceContainer(prefix, indentation);
+  const continuationIndent = Math.max(
+    fenceIndentationColumns(current),
+    current.leadingQuoteIndent,
+  );
+  const cacheKey = `${current.quoteDepth}:${continuationIndent}:${current.leadingQuoteIndent}`;
+  const cached = noListScanPositions.get(cacheKey);
+  if (cached?.container && position < cached.end) return cached.container;
+  const cachedPosition = cached?.noList;
+  const noList = () => {
+    noListScanPositions.set(cacheKey, { noList: position });
+    return null;
+  };
+  const foundList = container => {
+    noListScanPositions.set(cacheKey, {
+      container,
+      end: unfinishedContainerEnd(source, position, container, new Map()),
+    });
+    return container;
+  };
+  let lineEnd = position;
+  if (source[lineEnd - 1] === '\n') lineEnd -= 1;
+  if (source[lineEnd - 1] === '\r') lineEnd -= 1;
+
+  while (lineEnd > 0) {
+    if (cachedPosition != null && lineEnd < cachedPosition) return null;
+    const lineStart = source.lastIndexOf('\n', lineEnd - 1) + 1;
+    const line = source.slice(lineStart, lineEnd);
+    if (!line.trim()) {
+      if (!lineStart) break;
+      lineEnd = lineStart - 1;
+      if (source[lineEnd] === '\n') lineEnd -= 1;
+      if (source[lineEnd] === '\r') lineEnd -= 1;
+      continue;
+    }
+    const precedingFence = parseFenceLine(line);
+    if (precedingFence && fenceIndentationColumns(fenceContainer(precedingFence.prefix, precedingFence.indentation)) > 3) {
+      return noList();
+    }
+    const precedingContainer = fenceContainer(line);
+    const missingQuotes = current.quoteDepth - precedingContainer.quoteDepth;
+    if (missingQuotes < 0 || (missingQuotes && !current.leadingQuoteIndent)) return noList();
+
+    const quotePrefix = quotePrefixAt(line);
+    const content = line.slice(quotePrefix.length);
+    const sameQuoteContainer = precedingContainer.quoteDepth === current.quoteDepth
+      && (!current.quoteDepth || Boolean(quotePrefix));
+    const followsNonblankLine = lineStart > 0
+      && Boolean(source.slice(source.lastIndexOf('\n', lineStart - 2) + 1, lineStart - 1).trim());
+    const nonInterruptingListMarker = followsNonblankLine && sameQuoteContainer
+      && (/^[ \t]*[-+*][ \t]*$/.test(content)
+        || /^[ \t]*\d{1,9}[.)][ \t]*$/.test(content)
+        || (/^[ \t]*\d{1,9}[.)][ \t]/.test(content) && !/^[ \t]*1[.)][ \t]/.test(content)));
+    if (precedingContainer.listPrefix && !nonInterruptingListMarker) {
+      let container = missingQuotes
+        ? fenceContainer(`${precedingContainer.containerPrefix}${'> '.repeat(missingQuotes)}`)
+        : precedingContainer;
+      if (!missingQuotes) container = { ...container, rawPrefix: container.containerPrefix };
+      const emptyListMarker = line.length === precedingContainer.containerPrefix.length;
+      if (emptyListMarker) {
+        container = { ...container, listIndentGroups: [...container.listIndentGroups] };
+        if (container.lastListPrefixWidth > container.lastListMarkerWidth) {
+          const group = container.listIndentGroups.length - 1;
+          container.listIndentGroups[group] = container.listIndentGroups[group] - container.lastListPrefixWidth
+            + container.lastListMarkerWidth + 1;
+        }
+      }
+      const listIndent = container.listIndentGroups.at(-1);
+      if (listIndent && continuationIndent >= listIndent && continuationIndent <= listIndent + 3) {
+        return foundList(container);
+      }
+      return noList();
+    }
+
+    const lineIndentation = content.match(/^[ \t]*/)?.[0] || '';
+    const lineStartColumn = indentationColumns(quotePrefix);
+    const lineIndent = indentationColumnsAt(lineIndentation, lineStartColumn) - lineStartColumn;
+    // A fenced continuation may be up to three columns deeper than ordinary
+    // list content, so continue back to the enclosing list marker first.
+    if (lineIndent < 2) {
+      const thematicBreak = /^(?:(?:-[ \t]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})$/.test(content);
+      const lazyParagraph = sameQuoteContainer && !lineIndent
+        && !thematicBreak
+        && !startsInterruptingHtmlBlock(content)
+        && !/^(?:#{1,6}(?:\s|$)|(?:[-+*]|1[.)])[ \t]+\S|>|`{3,}|~{3,})/.test(content);
+      if (lazyParagraph) {
+        if (!lineStart) break;
+        lineEnd = lineStart - 1;
+        if (source[lineEnd] === '\n') lineEnd -= 1;
+        if (source[lineEnd] === '\r') lineEnd -= 1;
+        continue;
+      }
+      return noList();
+    }
+
+    if (!lineStart) break;
+    lineEnd = lineStart - 1;
+    if (source[lineEnd] === '\n') lineEnd -= 1;
+    if (source[lineEnd] === '\r') lineEnd -= 1;
+  }
+  return noList();
+}
+
+function lineBelongsToContainer(line, container) {
+  if (!container.quoteDepth && !container.listPrefix) return true;
+  const content = stripContainerPrefix(line, container);
+  return content != null && Boolean(content.trim());
+}
+
+function lineIsBlankInContainer(line, container) {
+  if (!container.quoteDepth && !container.listPrefix) return !line.trim();
+  return stripContainerPrefix(line, container) === '';
+}
+
+function lineHasExplicitContainerPrefix(line, container) {
+  return Boolean(String(line).trim()) && stripContainerPrefix(line, container) === '';
+}
+
+function containerBoundaryKey(container) {
+  return `${container.quoteDepth}:${container.leadingQuoteIndent}:${container.listPrefix}:${container.listIndentGroups.join(',')}`;
+}
+
+function unfinishedContainerEnd(source, start, container, boundaryCache) {
+  if (!container.quoteDepth && !container.listPrefix) return source.length;
+  const key = containerBoundaryKey(container);
+  const cached = boundaryCache.get(key);
+  if (cached && start >= cached.start && start <= cached.end) return cached.end;
+  const remainder = source.slice(start);
+  let offset = start;
+  let pendingBlankStart = null;
+  let end = source.length;
+  for (const match of remainder.matchAll(/[^\r\n]*(?:\r?\n|$)/g)) {
+    if (!match[0]) break;
+    const line = match[0].replace(/\r?\n$/, '');
+    if ((container.quoteDepth || container.listPrefix) && lineIsBlankInContainer(line, container)) {
+      if (lineHasExplicitContainerPrefix(line, container)) {
+        if (!container.quoteDepth) pendingBlankStart = null;
+      }
+      else if (pendingBlankStart == null) pendingBlankStart = offset;
+      offset += match[0].length;
+      continue;
+    }
+    if (!lineBelongsToContainer(line, container)) {
+      end = pendingBlankStart ?? offset;
+      break;
+    }
+    if (pendingBlankStart != null && container.quoteDepth) {
+      end = pendingBlankStart;
+      break;
+    }
+    pendingBlankStart = null;
+    offset += match[0].length;
+  }
+  if (pendingBlankStart != null && container.quoteDepth) end = pendingBlankStart;
+  boundaryCache.set(key, { start, end });
+  return end;
+}
+
+function normalizeContainerCode(code, prefixOrContainer, fenceIndentation = 0) {
+  const container = typeof prefixOrContainer === 'object'
+    ? prefixOrContainer
+    : fenceContainer(prefixOrContainer);
+  const { quoteDepth, listPrefix } = container;
+  if (!quoteDepth && !listPrefix && !fenceIndentation) return code;
+
+  const lines = String(code).split(/(\r?\n)/);
+  for (let index = 0; index < lines.length; index += 2) {
+    const normalized = stripContainerPrefix(lines[index], container);
+    const line = normalized != null ? normalized : lines[index];
+    lines[index] = fenceIndentation
+      ? stripIndentationColumns(line, fenceIndentation, indentationColumns(container.rawPrefix))
+      : line;
+  }
+  return lines.join('');
+}
+
+function parseFenceLine(line) {
+  let offset = 0;
+  while (offset < line.length) {
+    const segment = line.slice(offset);
+    const segmentStartColumn = indentationColumns(line.slice(0, offset));
+    const quote = quoteMarkerAt(segment, segmentStartColumn, true);
+    if (quote) {
+      offset += quote.length;
+      continue;
+    }
+    const list = listPrefixAt(segment, segmentStartColumn);
+    if (!list) break;
+    offset += list.length;
+  }
+  const prefix = line.slice(0, offset);
+  const indentation = line.slice(offset).match(/^[ \t]*/)?.[0] || '';
+  const fence = line.slice(offset + indentation.length).match(/^(`{3,}|~{3,})([^\r\n]*)$/);
+  if (!fence) return null;
+  return { prefix, indentation, fence: fence[1], info: fence[2] };
+}
+
+function markdownFenceLines(source) {
+  const lines = [];
+  for (const match of source.matchAll(/[^\r\n]*(?:\r?\n|$)/g)) {
+    if (!match[0]) break;
+    const raw = match[0];
+    const parsed = parseFenceLine(raw.replace(/\r?\n$/, ''));
+    if (parsed) lines.push({ ...parsed, index: match.index, raw });
+  }
+  return lines;
+}
+
+/** Replace whole fenced blocks, including an unfinished block during streaming. */
+export function replaceMarkdownCodeFences(value, renderBlock, { streaming = false } = {}) {
+  const source = String(value ?? '');
+  const output = [];
+  let cursor = 0;
+  let block = null;
+  const stack = [];
+  const noListScanPositions = new Map();
+  const containerBoundaryCache = new Map();
+
+  const matches = markdownFenceLines(source);
+  const containers = matches.map(match => fenceContainer(match.prefix, match.indentation));
+  const closerIndexes = new Map();
+  for (let index = 0; index < matches.length; index += 1) {
+    if (matches[index].info.trim()) continue;
+    const marker = matches[index].fence[0];
+    const indexes = closerIndexes.get(marker) || [];
+    indexes.push(index);
+    closerIndexes.set(marker, indexes);
+  }
+  const nestedCloserCache = new Map();
+  for (let matchIndex = 0; matchIndex < matches.length; matchIndex += 1) {
+    const match = matches[matchIndex];
+    const { prefix, indentation, fence, info } = match;
+    const container = containers[matchIndex];
+    if (block) {
+      const boundary = block.boundary;
+      if (boundary <= match.index) {
+        const code = source.slice(block.start, boundary);
+        const needsBoundaryNewline = (/\r?\n$/.test(code) || (!code && block.openingEndsWithNewline))
+          && !/^\r?\n/.test(source.slice(boundary));
+        output.push(block.prefix + renderBlock(
+          block.info,
+          normalizeContainerCode(code, block.container, block.fenceIndentation),
+        ) + (needsBoundaryNewline ? '\n' : ''));
+        cursor = boundary;
+        block = null;
+        stack.length = 0;
+        matchIndex -= 1;
+        continue;
+      }
+    }
+    const validOpening = fence[0] !== '`' || !info.includes('`');
+    const markdown = /^(?:md|markdown)$/i.test(codeFenceLanguage(info));
+    if (!block) {
+      // Four-space indented code is not a fenced block at the document root,
+      // but list continuations may require more than three spaces to close.
+      let openingContainer = container;
+      let openingPrefix = prefix;
+      if (!validOpening) continue;
+      const continuation = (fenceIndentationColumns(container) || container.leadingQuoteIndent || container.overIndentedQuote)
+        ? listContinuationContainer(source, match.index, prefix, indentation, noListScanPositions)
+        : null;
+      if (continuation) {
+        openingContainer = continuation;
+        openingPrefix = `${prefix}${indentation}`;
+      } else if (fenceIndentationColumns(container) > 3 || container.leadingQuoteIndent > 3 || container.overIndentedQuote) {
+        continue;
+      }
+      output.push(source.slice(cursor, match.index));
+      const start = match.index + match.raw.length;
+      block = {
+        info,
+        prefix: openingPrefix,
+        container: openingContainer,
+        start,
+        openingEndsWithNewline: /\r?\n$/.test(match.raw),
+        fenceIndentation: fenceIndentationInContainer(container, openingContainer),
+        boundary: unfinishedContainerEnd(source, start, openingContainer, containerBoundaryCache),
+      };
+      stack.push({ fence, markdown, container: openingContainer });
+      continue;
+    }
+
+    const active = stack[stack.length - 1];
+    // A closing fence occupies its own line, has no info string, and is at
+    // least as long as its opener. Backticks inside source code are literal.
+    const protectedNestedCloser = active.literalNestedCloserIndexes?.has(matchIndex);
+    if (!protectedNestedCloser && isFenceCloser(active, container, fence, info)) {
+      stack.pop();
+      if (!stack.length) {
+        output.push(block.prefix + renderBlock(
+          block.info,
+          normalizeContainerCode(source.slice(block.start, match.index), block.container, block.fenceIndentation),
+        ));
+        // Leave the closing line's newline for the surrounding Markdown.
+        cursor = match.index + match.raw.replace(/\r?\n$/, '').length;
+        block = null;
+      }
+    } else {
+      const nestedContainer = (fenceIndentationColumns(container) > 3 || container.leadingQuoteIndent > 3 || container.overIndentedQuote)
+        ? listContinuationContainer(source, match.index, prefix, indentation, noListScanPositions)
+        : container;
+      const nestedCloserIndex = nestedContainer
+        ? nestedFenceCloserIndex(matches, containers, closerIndexes, nestedCloserCache, matchIndex, fence, nestedContainer)
+        : -1;
+      if (nestedCloserIndex >= 0 && active.nestedOuterCloserIndex === undefined) {
+        active.nestedOuterCloserIndex = outerFenceCloserAfterNested(
+          source,
+          matches,
+          containers,
+          closerIndexes,
+          nestedCloserCache,
+          nestedCloserIndex,
+          active,
+          noListScanPositions,
+        );
+      }
+      const outerCloserIndex = active.nestedOuterCloserIndex;
+      if (streaming && active.markdown && validOpening && info.trim()
+        && nestedContainer
+        && nestedCloserIndex >= 0
+        && outerCloserIndex >= 0
+        && (!active.container.quoteDepth && !active.container.listPrefix
+          || fenceCloserInContainer(active.container, nestedContainer))) {
+        // Models sometimes wrap a README in ```markdown and reuse ```lang
+        // inside it. Recover only this named Markdown nesting; ordinary code
+        // and correctly longer outer fences retain their literal contents.
+        stack.push({ fence, markdown, container: nestedContainer });
+      } else if (streaming && active.markdown && nestedCloserIndex >= 0
+        && outerCloserIndex === -1) {
+        // An unfinished wrapper keeps every outer-compatible fence inside a
+        // complete nested example literal, including alternate-marker pairs.
+        const protectedClosers = active.literalNestedCloserIndexes ||= new Set();
+        // A longer outer marker at the nested closer is still the real outer
+        // closer; only a same-length or shorter nested fence protects it.
+        const protectedEnd = active.fence.length <= fence.length
+          ? nestedCloserIndex
+          : nestedCloserIndex - 1;
+        for (let index = matchIndex + 1; index <= protectedEnd; index += 1) {
+          if (isFenceCloser(active, containers[index], matches[index].fence, matches[index].info)) {
+            protectedClosers.add(index);
+          }
+        }
+      }
+    }
+  }
+
+  if (block) {
+    const end = block.boundary;
+    const code = source.slice(block.start, end);
+    const tail = source.slice(end);
+    const needsBoundaryNewline = tail && (/\r?\n$/.test(code) || (!code && block.openingEndsWithNewline))
+      && !/^\r?\n/.test(tail);
+    output.push(block.prefix + renderBlock(
+      block.info,
+      normalizeContainerCode(code, block.container, block.fenceIndentation),
+    ) + (needsBoundaryNewline ? '\n' : ''));
+    output.push(tail);
+  } else output.push(source.slice(cursor));
+  return output.join('');
+}
+
 function tokenSpan(type, value) {
   const escaped = escapeCodeHtml(value);
   return type ? `<span class="syntax-${type}">${escaped}</span>` : escaped;
diff --git a/src/chrome/src/ui/sidepanel.js b/src/chrome/src/ui/sidepanel.js
index bc6e8126d..8ce807ac5 100644
--- a/src/chrome/src/ui/sidepanel.js
+++ b/src/chrome/src/ui/sidepanel.js
@@ -7,7 +7,7 @@
 import { t, getLocale, setLocale, LANGUAGES, applyDOMTranslations, translationsForKey } from './i18n.js';
 import { CAPABILITY_LABEL } from '../agent/permission-gate.js';
 import { sanitizeMarkdownLinks } from './markdown-link.js';
-import { codeFenceLanguage, highlightCode, renderMarkdownHeadings, renderMarkdownTables } from './markdown-render.js';
+import { codeFenceLanguage, highlightCode, renderMarkdownHeadings, renderMarkdownTables, replaceMarkdownCodeFences } from './markdown-render.js';
 import { applyMode, loadMode, watch } from './theme.js';
 import {
   UI_SCALE_LEVELS,
@@ -3468,7 +3468,7 @@ async function settleScheduledRun(event, job, tabId = currentTabId) {
       ['completed', 'clarification_required'].includes(event)
       || watchPollEvent
     ) && job?.lastResult) {
-      textEl.innerHTML = formatMarkdown(job.lastResult);
+      textEl.innerHTML = formatMarkdown(job.lastResult, { recoverNestedMarkdown: true });
       addMessageCopyButton(assistantEl);
     }
   }
@@ -9221,7 +9221,7 @@ async function sendMessage(extraChatParams = {}) {
               retryPayload,
             })
             && !renderSubscribeError(textEl, res.content, modeForSend)) {
-          textEl.innerHTML = formatMarkdown(res.content);
+          textEl.innerHTML = formatMarkdown(res.content, { recoverNestedMarkdown: true });
         }
         addMessageCopyButton(assistantEl);
       }
@@ -10023,7 +10023,7 @@ function handleAgentUpdateMessage(msg) {
                 submittedTurnDurable: data.submittedTurnDurable,
                 retryPayload: activeRetryPayloadForRequest(eventTabId, msg.requestId),
               })
-              && !renderSubscribeError(textEl, data.finalContent)) textEl.innerHTML = formatMarkdown(data.finalContent);
+              && !renderSubscribeError(textEl, data.finalContent)) textEl.innerHTML = formatMarkdown(data.finalContent, { recoverNestedMarkdown: true });
           addMessageCopyButton(currentAssistantEl);
         }
       }
@@ -11200,7 +11200,7 @@ function renderStreamedAssistantMarkdownNow(textEl) {
   if (!textEl || textEl.dataset.suppressToolCallStream === 'true') return;
   const streamedText = getStreamedAssistantText(textEl);
   if (!streamedText) return;
-  textEl.innerHTML = formatMarkdown(streamedText, { enhance: false });
+  textEl.innerHTML = formatMarkdown(streamedText, { enhance: false, recoverNestedMarkdown: true });
   scrollToBottom();
 }
 
@@ -11263,13 +11263,15 @@ function renderAssistantTextUpdate(assistantEl, content, options = {}) {
   const streamedText = getStreamedAssistantText(textEl);
   const hasStreamedText = hasStreamedAssistantText(textEl);
   const restoredStreamNeedsReplacement = hasStreamedText && !streamedText;
+  // Final text must keep the same Markdown fence structure shown during streaming.
+  const renderedContent = formatMarkdown(content, { recoverNestedMarkdown: true });
 
   if (options.replace === true || restoredStreamNeedsReplacement) {
     // A rejected streamed terminal must replace its already-rendered deltas
     // even in Verbose mode; appending would leave the invalid plan visible.
     // Empty content clears the bubble (plan-only retry before recovery tools).
     if (content) {
-      textEl.innerHTML = formatMarkdown(content);
+      textEl.innerHTML = renderedContent;
       streamedAssistantTextByEl.set(textEl, String(content));
     } else {
       textEl.textContent = '';
@@ -11282,12 +11284,12 @@ function renderAssistantTextUpdate(assistantEl, content, options = {}) {
     // content in place even when cleanup changed it from the raw stream.
     const para = document.createElement('div');
     para.className = 'reasoning-step';
-    para.innerHTML = formatMarkdown(content);
+    para.innerHTML = renderedContent;
     textEl.appendChild(para);
   } else {
     // Compact mode keeps only the latest blurb. A streamed final lands here
     // too for one authoritative render with terminal-only enhancements.
-    textEl.innerHTML = formatMarkdown(content);
+    textEl.innerHTML = renderedContent;
   }
 
   clearStreamedAssistantText(textEl);
@@ -12109,7 +12111,7 @@ function addMessage(role, content, options = {}) {
     options.costAllowanceResume,
   )
       && !renderSubscribeError(textEl, content, options.subscribeResumeMode)) {
-    textEl.innerHTML = content ? formatMarkdown(content) : '';
+    textEl.innerHTML = content ? formatMarkdown(content, { recoverNestedMarkdown: role === 'assistant' }) : '';
   }
 
   contentEl.appendChild(textEl);
@@ -12336,7 +12338,7 @@ async function continueAgent(options = {}) {
               submittedTurnDurable: res.submittedTurnDurable,
             })
             && !renderSubscribeError(textEl, res.content)) {
-          textEl.innerHTML = formatMarkdown(res.content);
+          textEl.innerHTML = formatMarkdown(res.content, { recoverNestedMarkdown: true });
         }
         addMessageCopyButton(assistantEl);
       }
@@ -12826,15 +12828,16 @@ function scheduleMathRender() {
 function formatMarkdown(text, options = {}) {
   if (!text) return '';
   const enhance = options.enhance !== false;
+  const streaming = options.recoverNestedMarkdown === true;
 
   // 1. Extract fenced code blocks BEFORE escaping HTML
   const codeBlocks = [];
-  text = text.replace(/```[ \t]*([^`\r\n]*)\r?\n([\s\S]*?)```/g, (_match, info, code) => {
+  text = replaceMarkdownCodeFences(text, (info, code) => {
     const lang = codeFenceLanguage(info);
     const id = `__CODEBLOCK_${codeBlocks.length}__`;
     codeBlocks.push({ lang: lang || '', code });
     return id;
-  });
+  }, { streaming });
 
   // 2. Extract inline code before escaping
   const inlineCodes = [];
diff --git a/src/chrome/src/ui/skill-markdown.js b/src/chrome/src/ui/skill-markdown.js
index 5e65cb0cf..2dd0f4ac6 100644
--- a/src/chrome/src/ui/skill-markdown.js
+++ b/src/chrome/src/ui/skill-markdown.js
@@ -5,7 +5,7 @@
 
 import { escapeHtml } from './utils.js';
 import { sanitizeMarkdownLinks } from './markdown-link.js';
-import { renderMarkdownHeadings, renderMarkdownTables } from './markdown-render.js';
+import { renderMarkdownHeadings, renderMarkdownTables, replaceMarkdownCodeFences } from './markdown-render.js';
 
 function renderEmphasis(text) {
   return text
@@ -38,7 +38,7 @@ function renderInlineMarkdown(value) {
 export function renderSkillMarkdown(content) {
   let text = String(content || '');
   const codeBlocks = [];
-  text = text.replace(/```[ \t]*([^`\r\n]*)\r?\n([\s\S]*?)```/g, (_match, _info, code) => {
+  text = replaceMarkdownCodeFences(text, (_info, code) => {
     const placeholder = `__SKILL_CODE_BLOCK_${codeBlocks.length}__`;
     codeBlocks.push(code);
     return placeholder;
diff --git a/src/firefox/src/ui/history-text.js b/src/firefox/src/ui/history-text.js
index 074daadec..c72b3b6d6 100644
--- a/src/firefox/src/ui/history-text.js
+++ b/src/firefox/src/ui/history-text.js
@@ -125,10 +125,23 @@ export function historyTextFromElement(root, { markdown = true } = {}) {
     if (markdown && tagName === 'PRE') {
       const language = String(node.parentElement?.querySelector?.('.code-lang')?.textContent || '').trim();
       ensureBreak();
-      output += `\`\`\`${language}\n`;
+      const beforeCode = output;
+      output = '';
       for (const child of Array.from(node.childNodes || [])) visit(child, false, true);
       ensureBreak();
-      output += '```';
+      const code = output;
+      // History must not reintroduce ambiguous fences around a Markdown
+      // document (or any code sample containing literal backtick runs).
+      const fenceCharacter = language.includes('`') ? '~' : '`';
+      let fenceLength = 3;
+      for (const match of code.matchAll(new RegExp(`${fenceCharacter}{3,}`, 'g'))) {
+        fenceLength = Math.max(fenceLength, match[0].length + 1);
+      }
+      const fence = fenceCharacter.repeat(fenceLength);
+      // Keep an info string separate from the fence so a label beginning with
+      // the same marker cannot extend the opener past its matching closer.
+      const info = language ? ` ${language}` : '';
+      output = `${beforeCode}${fence}${info}\n${code}${fence}`;
       return;
     }
     if (markdown && tagName === 'CODE' && !inPre) {
diff --git a/src/firefox/src/ui/markdown-render.js b/src/firefox/src/ui/markdown-render.js
index f8aa7a878..8fb55931d 100644
--- a/src/firefox/src/ui/markdown-render.js
+++ b/src/firefox/src/ui/markdown-render.js
@@ -18,6 +18,7 @@ const LANGUAGE_ALIASES = Object.freeze({
   go: 'clike', rust: 'clike', rs: 'clike', swift: 'clike',
   php: 'clike', ruby: 'clike', rb: 'clike',
 });
+const INTERRUPTING_HTML_BLOCK_TAGS = new Set(('address article aside base basefont blockquote body caption center col colgroup dd details dialog dir div dl dt fieldset figcaption figure footer form frame frameset h1 h2 h3 h4 h5 h6 head header hr html iframe legend li link main menu menuitem nav noframes ol optgroup option p param search section summary table tbody td tfoot th thead title tr track ul').split(' '));
 
 const JS_KEYWORDS = new Set(('abstract as async await break case catch class const continue debugger declare default delete do else enum export extends finally for from function get if implements import in infer instanceof interface keyof let namespace new of private protected public readonly return satisfies set static super switch throw try type typeof var void while with yield').split(' '));
 const JS_CONSTANTS = new Set(('true false null undefined NaN Infinity').split(' '));
@@ -57,6 +58,618 @@ export function codeFenceLanguage(infoString) {
   return String(infoString || '').trim().split(/\s+/, 1)[0] || '';
 }
 
+function fenceContainer(prefix, indentation = '') {
+  const source = String(prefix);
+  const quotePrefix = quotePrefixAt(source);
+  let remainder = source;
+  let listPrefix = '';
+  let quoteDepth = 0;
+  let overIndentedQuote = false;
+  let lastListMarkerWidth = 0;
+  let lastListPrefixWidth = 0;
+  const listIndentGroups = [0];
+  while (remainder) {
+    const containerStartColumn = indentationColumns(source.slice(0, source.length - remainder.length));
+    // Preserve a deeply indented quote only long enough to resolve a
+    // continuation from an enclosing list; it is never a container itself.
+    const quote = quoteMarkerAt(remainder, containerStartColumn, true);
+    if (quote) {
+      quoteDepth += 1;
+      overIndentedQuote ||= quote.overIndented;
+      listIndentGroups.push(0);
+      remainder = remainder.slice(quote.length);
+      continue;
+    }
+    const list = listPrefixAt(remainder, containerStartColumn);
+    if (!list) break;
+    listPrefix += list;
+    lastListPrefixWidth = indentationColumnsAt(list, containerStartColumn) - containerStartColumn;
+    lastListMarkerWidth = indentationColumnsAt(list.replace(/[ \t]+$/, ''), containerStartColumn) - containerStartColumn;
+    const implicitListPadding = !/[ \t]$/.test(list) && remainder === list ? 1 : 0;
+    listIndentGroups[listIndentGroups.length - 1] += indentationColumnsAt(list, containerStartColumn) - containerStartColumn
+      + implicitListPadding;
+    remainder = remainder.slice(list.length);
+  }
+  return {
+    containerPrefix: source.slice(0, source.length - remainder.length),
+    quotePrefix,
+    quoteDepth,
+    listPrefix,
+    lastListMarkerWidth,
+    lastListPrefixWidth,
+    listIndentGroups,
+    overIndentedQuote,
+    leadingQuoteIndent: indentationColumns(source.match(/^[ \t]*(?=>)/)?.[0] || ''),
+    rawPrefix: source,
+    indentation: String(indentation),
+  };
+}
+
+function indentationColumnsAt(value, startColumn = 0) {
+  let columns = startColumn;
+  for (const character of String(value)) {
+    columns += character === '\t' ? 4 - (columns % 4) : 1;
+  }
+  return columns;
+}
+
+function indentationColumns(value) {
+  return indentationColumnsAt(value);
+}
+
+function listPrefixAt(value, startColumn = 0) {
+  const source = String(value);
+  const marker = source.match(/^[ \t]*(?:[-+*]|\d{1,9}[.)])/);
+  const leadingIndentation = marker?.[0].match(/^[ \t]*/)?.[0] || '';
+  const next = source[marker?.[0].length];
+  if (!marker
+    || indentationColumnsAt(leadingIndentation, startColumn) - startColumn > 3
+    || (next && !/^[ \t]$/.test(next))) return null;
+  let offset = marker[0].length;
+  let column = indentationColumnsAt(marker[0], startColumn);
+  let paddingColumns = 0;
+  while (/^[ \t]$/.test(value[offset] || '')) {
+    const width = value[offset] === '\t' ? 4 - (column % 4) : 1;
+    paddingColumns += width;
+    column += width;
+    offset += 1;
+  }
+  if (paddingColumns > 4 && source[marker[0].length] === '\t') {
+    return `${source.slice(0, marker[0].length)} `;
+  }
+  return source.slice(0, marker[0].length + (paddingColumns <= 4 ? offset - marker[0].length : 1));
+}
+
+function quoteMarkerAt(value, startColumn = 0, allowOverIndentation = false) {
+  let offset = 0;
+  let column = startColumn;
+  while (/^[ \t]$/.test(value[offset] || '')) {
+    const width = value[offset] === '\t' ? 4 - (column % 4) : 1;
+    if (!allowOverIndentation && column + width - startColumn > 3) break;
+    column += width;
+    offset += 1;
+  }
+  const marker = String(value).slice(offset).match(/^>[ \t]?/);
+  if (!marker) return null;
+  return {
+    length: offset + marker[0].length,
+    column: indentationColumnsAt(marker[0], column),
+    overIndented: column - startColumn > 3,
+  };
+}
+
+function quotePrefixAt(value, startColumn = 0) {
+  const source = String(value);
+  let offset = 0;
+  let column = startColumn;
+  while (offset < source.length) {
+    const quote = quoteMarkerAt(source.slice(offset), column);
+    if (!quote) break;
+    offset += quote.length;
+    column = quote.column;
+  }
+  return source.slice(0, offset);
+}
+
+function fenceIndentationColumns(container) {
+  const startColumn = indentationColumns(container.rawPrefix);
+  return indentationColumnsAt(container.indentation, startColumn) - startColumn;
+}
+
+function consumeIndentationColumns(line, columns, startColumn = 0) {
+  let offset = 0;
+  let consumed = 0;
+  let column = startColumn;
+  while (offset < line.length && consumed < columns && /^[ \t]$/.test(line[offset])) {
+    if (line[offset] === '\t') {
+      const tabWidth = 4 - (column % 4);
+      if (consumed + tabWidth > columns) {
+        return `${' '.repeat(consumed + tabWidth - columns)}${line.slice(offset + 1)}`;
+      }
+      consumed += tabWidth;
+      column += tabWidth;
+    } else {
+      consumed += 1;
+      column += 1;
+    }
+    offset += 1;
+  }
+  return consumed === columns ? line.slice(offset) : null;
+}
+
+function stripIndentationColumns(line, columns, startColumn = 0) {
+  const stripped = consumeIndentationColumns(line, columns, startColumn);
+  if (stripped != null) return stripped;
+  return String(line).replace(/^[ \t]*/, '');
+}
+
+function stripContainerPrefix(line, container) {
+  let remainder = String(line);
+  let column = 0;
+  for (let quoteIndex = 0; quoteIndex < container.quoteDepth; quoteIndex += 1) {
+    if (!remainder.trim()) return '';
+    const listIndent = container.listIndentGroups[quoteIndex];
+    remainder = consumeIndentationColumns(remainder, listIndent, column);
+    if (remainder == null) return null;
+    column += listIndent;
+    const quote = quoteMarkerAt(remainder, column);
+    if (!quote) return null;
+    column = quote.column;
+    remainder = remainder.slice(quote.length);
+  }
+  if (!remainder.trim()) return '';
+  return consumeIndentationColumns(remainder, container.listIndentGroups.at(-1), column);
+}
+
+function fenceIndentationInContainer(fence, container) {
+  const indentation = fenceIndentationColumns(fence);
+  if (fence.listPrefix) return indentation;
+  return Math.max(0, indentation - container.listIndentGroups.at(-1));
+}
+
+function fenceCloserInContainer(opener, candidate) {
+  if (!opener.quoteDepth && !opener.listPrefix) {
+    return !candidate.quoteDepth && !candidate.listPrefix
+      && indentationColumns(candidate.indentation) <= 3;
+  }
+  const remainder = stripContainerPrefix(`${candidate.rawPrefix}${candidate.indentation}x`, opener);
+  const extraIndentation = remainder?.slice(0, -1);
+  return remainder?.endsWith('x')
+    && /^[ \t]*$/.test(extraIndentation)
+    && indentationColumnsAt(extraIndentation, indentationColumns(opener.rawPrefix)) - indentationColumns(opener.rawPrefix) <= 3;
+}
+
+function isFenceCloser(opener, candidate, fence, info) {
+  return fenceCloserInContainer(opener.container, candidate)
+    && !info.trim()
+    && fence[0] === opener.fence[0]
+    && fence.length >= opener.fence.length;
+}
+
+function nestedFenceCloserIndex(matches, containers, closerIndexes, cache, startIndex, fence, container) {
+  const key = `${fence[0]}:${fence.length}:${container.quoteDepth}:${container.listIndentGroups.join(',')}`;
+  let compatible = cache.get(key);
+  if (!compatible) {
+    const nested = { fence, container };
+    compatible = (closerIndexes.get(fence[0]) || []).filter(index => (
+      isFenceCloser(nested, containers[index], matches[index].fence, matches[index].info)
+    ));
+    cache.set(key, compatible);
+  }
+  let low = 0;
+  let high = compatible.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (compatible[middle] <= startIndex) low = middle + 1;
+    else high = middle;
+  }
+  return low < compatible.length ? compatible[low] : -1;
+}
+
+function outerFenceCloserAfterNested(
+  source,
+  matches,
+  containers,
+  closerIndexes,
+  cache,
+  startIndex,
+  outer,
+  noListScanPositions,
+) {
+  for (let index = startIndex + 1; index < matches.length; index += 1) {
+    const match = matches[index];
+    const container = containers[index];
+    if (isFenceCloser(outer, container, match.fence, match.info)) return index;
+
+    const validOpening = match.fence[0] !== '`' || !match.info.includes('`');
+    if (!validOpening || !match.info.trim()) continue;
+    const nestedContainer = (fenceIndentationColumns(container) > 3 || container.leadingQuoteIndent > 3 || container.overIndentedQuote)
+      ? listContinuationContainer(source, match.index, match.prefix, match.indentation, noListScanPositions)
+      : container;
+    if (!nestedContainer) continue;
+    const nestedCloserIndex = nestedFenceCloserIndex(
+      matches,
+      containers,
+      closerIndexes,
+      cache,
+      index,
+      match.fence,
+      nestedContainer,
+    );
+    if (nestedCloserIndex >= 0) index = nestedCloserIndex;
+  }
+  return -1;
+}
+
+function startsInterruptingHtmlBlock(content) {
+  // CommonMark HTML block types 1–6 interrupt paragraphs; inline tags do not.
+  if (/^(?:<!--|<\?|<![A-Za-z]|<!\[CDATA\[|<(?:pre|script|style|textarea)(?=[ \t>]|$))/i.test(content)) return true;
+  const tag = content.match(/^<\/?([A-Za-z][A-Za-z0-9-]*)(?=[ \t>]|\/>|$)/);
+  return Boolean(tag && INTERRUPTING_HTML_BLOCK_TAGS.has(tag[1].toLowerCase()));
+}
+
+function listContinuationContainer(source, position, prefix, indentation, noListScanPositions) {
+  const current = fenceContainer(prefix, indentation);
+  const continuationIndent = Math.max(
+    fenceIndentationColumns(current),
+    current.leadingQuoteIndent,
+  );
+  const cacheKey = `${current.quoteDepth}:${continuationIndent}:${current.leadingQuoteIndent}`;
+  const cached = noListScanPositions.get(cacheKey);
+  if (cached?.container && position < cached.end) return cached.container;
+  const cachedPosition = cached?.noList;
+  const noList = () => {
+    noListScanPositions.set(cacheKey, { noList: position });
+    return null;
+  };
+  const foundList = container => {
+    noListScanPositions.set(cacheKey, {
+      container,
+      end: unfinishedContainerEnd(source, position, container, new Map()),
+    });
+    return container;
+  };
+  let lineEnd = position;
+  if (source[lineEnd - 1] === '\n') lineEnd -= 1;
+  if (source[lineEnd - 1] === '\r') lineEnd -= 1;
+
+  while (lineEnd > 0) {
+    if (cachedPosition != null && lineEnd < cachedPosition) return null;
+    const lineStart = source.lastIndexOf('\n', lineEnd - 1) + 1;
+    const line = source.slice(lineStart, lineEnd);
+    if (!line.trim()) {
+      if (!lineStart) break;
+      lineEnd = lineStart - 1;
+      if (source[lineEnd] === '\n') lineEnd -= 1;
+      if (source[lineEnd] === '\r') lineEnd -= 1;
+      continue;
+    }
+    const precedingFence = parseFenceLine(line);
+    if (precedingFence && fenceIndentationColumns(fenceContainer(precedingFence.prefix, precedingFence.indentation)) > 3) {
+      return noList();
+    }
+    const precedingContainer = fenceContainer(line);
+    const missingQuotes = current.quoteDepth - precedingContainer.quoteDepth;
+    if (missingQuotes < 0 || (missingQuotes && !current.leadingQuoteIndent)) return noList();
+
+    const quotePrefix = quotePrefixAt(line);
+    const content = line.slice(quotePrefix.length);
+    const sameQuoteContainer = precedingContainer.quoteDepth === current.quoteDepth
+      && (!current.quoteDepth || Boolean(quotePrefix));
+    const followsNonblankLine = lineStart > 0
+      && Boolean(source.slice(source.lastIndexOf('\n', lineStart - 2) + 1, lineStart - 1).trim());
+    const nonInterruptingListMarker = followsNonblankLine && sameQuoteContainer
+      && (/^[ \t]*[-+*][ \t]*$/.test(content)
+        || /^[ \t]*\d{1,9}[.)][ \t]*$/.test(content)
+        || (/^[ \t]*\d{1,9}[.)][ \t]/.test(content) && !/^[ \t]*1[.)][ \t]/.test(content)));
+    if (precedingContainer.listPrefix && !nonInterruptingListMarker) {
+      let container = missingQuotes
+        ? fenceContainer(`${precedingContainer.containerPrefix}${'> '.repeat(missingQuotes)}`)
+        : precedingContainer;
+      if (!missingQuotes) container = { ...container, rawPrefix: container.containerPrefix };
+      const emptyListMarker = line.length === precedingContainer.containerPrefix.length;
+      if (emptyListMarker) {
+        container = { ...container, listIndentGroups: [...container.listIndentGroups] };
+        if (container.lastListPrefixWidth > container.lastListMarkerWidth) {
+          const group = container.listIndentGroups.length - 1;
+          container.listIndentGroups[group] = container.listIndentGroups[group] - container.lastListPrefixWidth
+            + container.lastListMarkerWidth + 1;
+        }
+      }
+      const listIndent = container.listIndentGroups.at(-1);
+      if (listIndent && continuationIndent >= listIndent && continuationIndent <= listIndent + 3) {
+        return foundList(container);
+      }
+      return noList();
+    }
+
+    const lineIndentation = content.match(/^[ \t]*/)?.[0] || '';
+    const lineStartColumn = indentationColumns(quotePrefix);
+    const lineIndent = indentationColumnsAt(lineIndentation, lineStartColumn) - lineStartColumn;
+    // A fenced continuation may be up to three columns deeper than ordinary
+    // list content, so continue back to the enclosing list marker first.
+    if (lineIndent < 2) {
+      const thematicBreak = /^(?:(?:-[ \t]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})$/.test(content);
+      const lazyParagraph = sameQuoteContainer && !lineIndent
+        && !thematicBreak
+        && !startsInterruptingHtmlBlock(content)
+        && !/^(?:#{1,6}(?:\s|$)|(?:[-+*]|1[.)])[ \t]+\S|>|`{3,}|~{3,})/.test(content);
+      if (lazyParagraph) {
+        if (!lineStart) break;
+        lineEnd = lineStart - 1;
+        if (source[lineEnd] === '\n') lineEnd -= 1;
+        if (source[lineEnd] === '\r') lineEnd -= 1;
+        continue;
+      }
+      return noList();
+    }
+
+    if (!lineStart) break;
+    lineEnd = lineStart - 1;
+    if (source[lineEnd] === '\n') lineEnd -= 1;
+    if (source[lineEnd] === '\r') lineEnd -= 1;
+  }
+  return noList();
+}
+
+function lineBelongsToContainer(line, container) {
+  if (!container.quoteDepth && !container.listPrefix) return true;
+  const content = stripContainerPrefix(line, container);
+  return content != null && Boolean(content.trim());
+}
+
+function lineIsBlankInContainer(line, container) {
+  if (!container.quoteDepth && !container.listPrefix) return !line.trim();
+  return stripContainerPrefix(line, container) === '';
+}
+
+function lineHasExplicitContainerPrefix(line, container) {
+  return Boolean(String(line).trim()) && stripContainerPrefix(line, container) === '';
+}
+
+function containerBoundaryKey(container) {
+  return `${container.quoteDepth}:${container.leadingQuoteIndent}:${container.listPrefix}:${container.listIndentGroups.join(',')}`;
+}
+
+function unfinishedContainerEnd(source, start, container, boundaryCache) {
+  if (!container.quoteDepth && !container.listPrefix) return source.length;
+  const key = containerBoundaryKey(container);
+  const cached = boundaryCache.get(key);
+  if (cached && start >= cached.start && start <= cached.end) return cached.end;
+  const remainder = source.slice(start);
+  let offset = start;
+  let pendingBlankStart = null;
+  let end = source.length;
+  for (const match of remainder.matchAll(/[^\r\n]*(?:\r?\n|$)/g)) {
+    if (!match[0]) break;
+    const line = match[0].replace(/\r?\n$/, '');
+    if ((container.quoteDepth || container.listPrefix) && lineIsBlankInContainer(line, container)) {
+      if (lineHasExplicitContainerPrefix(line, container)) {
+        if (!container.quoteDepth) pendingBlankStart = null;
+      }
+      else if (pendingBlankStart == null) pendingBlankStart = offset;
+      offset += match[0].length;
+      continue;
+    }
+    if (!lineBelongsToContainer(line, container)) {
+      end = pendingBlankStart ?? offset;
+      break;
+    }
+    if (pendingBlankStart != null && container.quoteDepth) {
+      end = pendingBlankStart;
+      break;
+    }
+    pendingBlankStart = null;
+    offset += match[0].length;
+  }
+  if (pendingBlankStart != null && container.quoteDepth) end = pendingBlankStart;
+  boundaryCache.set(key, { start, end });
+  return end;
+}
+
+function normalizeContainerCode(code, prefixOrContainer, fenceIndentation = 0) {
+  const container = typeof prefixOrContainer === 'object'
+    ? prefixOrContainer
+    : fenceContainer(prefixOrContainer);
+  const { quoteDepth, listPrefix } = container;
+  if (!quoteDepth && !listPrefix && !fenceIndentation) return code;
+
+  const lines = String(code).split(/(\r?\n)/);
+  for (let index = 0; index < lines.length; index += 2) {
+    const normalized = stripContainerPrefix(lines[index], container);
+    const line = normalized != null ? normalized : lines[index];
+    lines[index] = fenceIndentation
+      ? stripIndentationColumns(line, fenceIndentation, indentationColumns(container.rawPrefix))
+      : line;
+  }
+  return lines.join('');
+}
+
+function parseFenceLine(line) {
+  let offset = 0;
+  while (offset < line.length) {
+    const segment = line.slice(offset);
+    const segmentStartColumn = indentationColumns(line.slice(0, offset));
+    const quote = quoteMarkerAt(segment, segmentStartColumn, true);
+    if (quote) {
+      offset += quote.length;
+      continue;
+    }
+    const list = listPrefixAt(segment, segmentStartColumn);
+    if (!list) break;
+    offset += list.length;
+  }
+  const prefix = line.slice(0, offset);
+  const indentation = line.slice(offset).match(/^[ \t]*/)?.[0] || '';
+  const fence = line.slice(offset + indentation.length).match(/^(`{3,}|~{3,})([^\r\n]*)$/);
+  if (!fence) return null;
+  return { prefix, indentation, fence: fence[1], info: fence[2] };
+}
+
+function markdownFenceLines(source) {
+  const lines = [];
+  for (const match of source.matchAll(/[^\r\n]*(?:\r?\n|$)/g)) {
+    if (!match[0]) break;
+    const raw = match[0];
+    const parsed = parseFenceLine(raw.replace(/\r?\n$/, ''));
+    if (parsed) lines.push({ ...parsed, index: match.index, raw });
+  }
+  return lines;
+}
+
+/** Replace whole fenced blocks, including an unfinished block during streaming. */
+export function replaceMarkdownCodeFences(value, renderBlock, { streaming = false } = {}) {
+  const source = String(value ?? '');
+  const output = [];
+  let cursor = 0;
+  let block = null;
+  const stack = [];
+  const noListScanPositions = new Map();
+  const containerBoundaryCache = new Map();
+
+  const matches = markdownFenceLines(source);
+  const containers = matches.map(match => fenceContainer(match.prefix, match.indentation));
+  const closerIndexes = new Map();
+  for (let index = 0; index < matches.length; index += 1) {
+    if (matches[index].info.trim()) continue;
+    const marker = matches[index].fence[0];
+    const indexes = closerIndexes.get(marker) || [];
+    indexes.push(index);
+    closerIndexes.set(marker, indexes);
+  }
+  const nestedCloserCache = new Map();
+  for (let matchIndex = 0; matchIndex < matches.length; matchIndex += 1) {
+    const match = matches[matchIndex];
+    const { prefix, indentation, fence, info } = match;
+    const container = containers[matchIndex];
+    if (block) {
+      const boundary = block.boundary;
+      if (boundary <= match.index) {
+        const code = source.slice(block.start, boundary);
+        const needsBoundaryNewline = (/\r?\n$/.test(code) || (!code && block.openingEndsWithNewline))
+          && !/^\r?\n/.test(source.slice(boundary));
+        output.push(block.prefix + renderBlock(
+          block.info,
+          normalizeContainerCode(code, block.container, block.fenceIndentation),
+        ) + (needsBoundaryNewline ? '\n' : ''));
+        cursor = boundary;
+        block = null;
+        stack.length = 0;
+        matchIndex -= 1;
+        continue;
+      }
+    }
+    const validOpening = fence[0] !== '`' || !info.includes('`');
+    const markdown = /^(?:md|markdown)$/i.test(codeFenceLanguage(info));
+    if (!block) {
+      // Four-space indented code is not a fenced block at the document root,
+      // but list continuations may require more than three spaces to close.
+      let openingContainer = container;
+      let openingPrefix = prefix;
+      if (!validOpening) continue;
+      const continuation = (fenceIndentationColumns(container) || container.leadingQuoteIndent || container.overIndentedQuote)
+        ? listContinuationContainer(source, match.index, prefix, indentation, noListScanPositions)
+        : null;
+      if (continuation) {
+        openingContainer = continuation;
+        openingPrefix = `${prefix}${indentation}`;
+      } else if (fenceIndentationColumns(container) > 3 || container.leadingQuoteIndent > 3 || container.overIndentedQuote) {
+        continue;
+      }
+      output.push(source.slice(cursor, match.index));
+      const start = match.index + match.raw.length;
+      block = {
+        info,
+        prefix: openingPrefix,
+        container: openingContainer,
+        start,
+        openingEndsWithNewline: /\r?\n$/.test(match.raw),
+        fenceIndentation: fenceIndentationInContainer(container, openingContainer),
+        boundary: unfinishedContainerEnd(source, start, openingContainer, containerBoundaryCache),
+      };
+      stack.push({ fence, markdown, container: openingContainer });
+      continue;
+    }
+
+    const active = stack[stack.length - 1];
+    // A closing fence occupies its own line, has no info string, and is at
+    // least as long as its opener. Backticks inside source code are literal.
+    const protectedNestedCloser = active.literalNestedCloserIndexes?.has(matchIndex);
+    if (!protectedNestedCloser && isFenceCloser(active, container, fence, info)) {
+      stack.pop();
+      if (!stack.length) {
+        output.push(block.prefix + renderBlock(
+          block.info,
+          normalizeContainerCode(source.slice(block.start, match.index), block.container, block.fenceIndentation),
+        ));
+        // Leave the closing line's newline for the surrounding Markdown.
+        cursor = match.index + match.raw.replace(/\r?\n$/, '').length;
+        block = null;
+      }
+    } else {
+      const nestedContainer = (fenceIndentationColumns(container) > 3 || container.leadingQuoteIndent > 3 || container.overIndentedQuote)
+        ? listContinuationContainer(source, match.index, prefix, indentation, noListScanPositions)
+        : container;
+      const nestedCloserIndex = nestedContainer
+        ? nestedFenceCloserIndex(matches, containers, closerIndexes, nestedCloserCache, matchIndex, fence, nestedContainer)
+        : -1;
+      if (nestedCloserIndex >= 0 && active.nestedOuterCloserIndex === undefined) {
+        active.nestedOuterCloserIndex = outerFenceCloserAfterNested(
+          source,
+          matches,
+          containers,
+          closerIndexes,
+          nestedCloserCache,
+          nestedCloserIndex,
+          active,
+          noListScanPositions,
+        );
+      }
+      const outerCloserIndex = active.nestedOuterCloserIndex;
+      if (streaming && active.markdown && validOpening && info.trim()
+        && nestedContainer
+        && nestedCloserIndex >= 0
+        && outerCloserIndex >= 0
+        && (!active.container.quoteDepth && !active.container.listPrefix
+          || fenceCloserInContainer(active.container, nestedContainer))) {
+        // Models sometimes wrap a README in ```markdown and reuse ```lang
+        // inside it. Recover only this named Markdown nesting; ordinary code
+        // and correctly longer outer fences retain their literal contents.
+        stack.push({ fence, markdown, container: nestedContainer });
+      } else if (streaming && active.markdown && nestedCloserIndex >= 0
+        && outerCloserIndex === -1) {
+        // An unfinished wrapper keeps every outer-compatible fence inside a
+        // complete nested example literal, including alternate-marker pairs.
+        const protectedClosers = active.literalNestedCloserIndexes ||= new Set();
+        // A longer outer marker at the nested closer is still the real outer
+        // closer; only a same-length or shorter nested fence protects it.
+        const protectedEnd = active.fence.length <= fence.length
+          ? nestedCloserIndex
+          : nestedCloserIndex - 1;
+        for (let index = matchIndex + 1; index <= protectedEnd; index += 1) {
+          if (isFenceCloser(active, containers[index], matches[index].fence, matches[index].info)) {
+            protectedClosers.add(index);
+          }
+        }
+      }
+    }
+  }
+
+  if (block) {
+    const end = block.boundary;
+    const code = source.slice(block.start, end);
+    const tail = source.slice(end);
+    const needsBoundaryNewline = tail && (/\r?\n$/.test(code) || (!code && block.openingEndsWithNewline))
+      && !/^\r?\n/.test(tail);
+    output.push(block.prefix + renderBlock(
+      block.info,
+      normalizeContainerCode(code, block.container, block.fenceIndentation),
+    ) + (needsBoundaryNewline ? '\n' : ''));
+    output.push(tail);
+  } else output.push(source.slice(cursor));
+  return output.join('');
+}
+
 function tokenSpan(type, value) {
   const escaped = escapeCodeHtml(value);
   return type ? `<span class="syntax-${type}">${escaped}</span>` : escaped;
diff --git a/src/firefox/src/ui/sidepanel.js b/src/firefox/src/ui/sidepanel.js
index 12c8ec3e6..c27b46f56 100644
--- a/src/firefox/src/ui/sidepanel.js
+++ b/src/firefox/src/ui/sidepanel.js
@@ -7,7 +7,7 @@
 import { t, getLocale, setLocale, LANGUAGES, applyDOMTranslations, translationsForKey } from './i18n.js';
 import { CAPABILITY_LABEL } from '../agent/permission-gate.js';
 import { sanitizeMarkdownLinks } from './markdown-link.js';
-import { codeFenceLanguage, highlightCode, renderMarkdownHeadings, renderMarkdownTables } from './markdown-render.js';
+import { codeFenceLanguage, highlightCode, renderMarkdownHeadings, renderMarkdownTables, replaceMarkdownCodeFences } from './markdown-render.js';
 import { applyMode, loadMode, watch } from './theme.js';
 import {
   UI_SCALE_LEVELS,
@@ -3319,7 +3319,7 @@ async function settleScheduledRun(event, job, tabId = currentTabId) {
       ['completed', 'clarification_required'].includes(event)
       || watchPollEvent
     ) && job?.lastResult) {
-      textEl.innerHTML = formatMarkdown(job.lastResult);
+      textEl.innerHTML = formatMarkdown(job.lastResult, { recoverNestedMarkdown: true });
       addMessageCopyButton(assistantEl);
     }
   }
@@ -8872,7 +8872,7 @@ async function sendMessage(extraChatParams = {}) {
               retryPayload,
             })
             && !renderSubscribeError(textEl, res.content, modeForSend)) {
-          textEl.innerHTML = formatMarkdown(res.content);
+          textEl.innerHTML = formatMarkdown(res.content, { recoverNestedMarkdown: true });
         }
         addMessageCopyButton(assistantEl);
       }
@@ -9483,7 +9483,7 @@ function handleAgentUpdateMessage(msg) {
                 submittedTurnDurable: data.submittedTurnDurable,
                 retryPayload: activeRetryPayloadForRequest(eventTabId, msg.requestId),
               })
-              && !renderSubscribeError(textEl, data.finalContent)) textEl.innerHTML = formatMarkdown(data.finalContent);
+              && !renderSubscribeError(textEl, data.finalContent)) textEl.innerHTML = formatMarkdown(data.finalContent, { recoverNestedMarkdown: true });
           addMessageCopyButton(currentAssistantEl);
         }
       }
@@ -10799,7 +10799,7 @@ function renderStreamedAssistantMarkdownNow(textEl) {
   if (!textEl || textEl.dataset.suppressToolCallStream === 'true') return;
   const streamedText = getStreamedAssistantText(textEl);
   if (!streamedText) return;
-  textEl.innerHTML = formatMarkdown(streamedText, { enhance: false });
+  textEl.innerHTML = formatMarkdown(streamedText, { enhance: false, recoverNestedMarkdown: true });
   scrollToBottom();
 }
 
@@ -10862,13 +10862,15 @@ function renderAssistantTextUpdate(assistantEl, content, options = {}) {
   const streamedText = getStreamedAssistantText(textEl);
   const hasStreamedText = hasStreamedAssistantText(textEl);
   const restoredStreamNeedsReplacement = hasStreamedText && !streamedText;
+  // Final text must keep the same Markdown fence structure shown during streaming.
+  const renderedContent = formatMarkdown(content, { recoverNestedMarkdown: true });
 
   if (options.replace === true || restoredStreamNeedsReplacement) {
     // A rejected streamed terminal must replace its already-rendered deltas
     // even in Verbose mode; appending would leave the invalid plan visible.
     // Empty content clears the bubble (plan-only retry before recovery tools).
     if (content) {
-      textEl.innerHTML = formatMarkdown(content);
+      textEl.innerHTML = renderedContent;
       streamedAssistantTextByEl.set(textEl, String(content));
     } else {
       textEl.textContent = '';
@@ -10881,12 +10883,12 @@ function renderAssistantTextUpdate(assistantEl, content, options = {}) {
     // content in place even when cleanup changed it from the raw stream.
     const para = document.createElement('div');
     para.className = 'reasoning-step';
-    para.innerHTML = formatMarkdown(content);
+    para.innerHTML = renderedContent;
     textEl.appendChild(para);
   } else {
     // Compact mode keeps only the latest blurb. A streamed final lands here
     // too for one authoritative render with terminal-only enhancements.
-    textEl.innerHTML = formatMarkdown(content);
+    textEl.innerHTML = renderedContent;
   }
 
   clearStreamedAssistantText(textEl);
@@ -11708,7 +11710,7 @@ function addMessage(role, content, options = {}) {
     options.costAllowanceResume,
   )
       && !renderSubscribeError(textEl, content, options.subscribeResumeMode)) {
-    textEl.innerHTML = content ? formatMarkdown(content) : '';
+    textEl.innerHTML = content ? formatMarkdown(content, { recoverNestedMarkdown: role === 'assistant' }) : '';
   }
 
   contentEl.appendChild(textEl);
@@ -11932,7 +11934,7 @@ async function continueAgent(options = {}) {
               submittedTurnDurable: res.submittedTurnDurable,
             })
             && !renderSubscribeError(textEl, res.content)) {
-          textEl.innerHTML = formatMarkdown(res.content);
+          textEl.innerHTML = formatMarkdown(res.content, { recoverNestedMarkdown: true });
         }
         addMessageCopyButton(assistantEl);
       }
@@ -12413,15 +12415,16 @@ function scheduleMathRender() {
 function formatMarkdown(text, options = {}) {
   if (!text) return '';
   const enhance = options.enhance !== false;
+  const streaming = options.recoverNestedMarkdown === true;
 
   // 1. Extract fenced code blocks BEFORE escaping HTML
   const codeBlocks = [];
-  text = text.replace(/```[ \t]*([^`\r\n]*)\r?\n([\s\S]*?)```/g, (_match, info, code) => {
+  text = replaceMarkdownCodeFences(text, (info, code) => {
     const lang = codeFenceLanguage(info);
     const id = `__CODEBLOCK_${codeBlocks.length}__`;
     codeBlocks.push({ lang: lang || '', code });
     return id;
-  });
+  }, { streaming });
 
   // 2. Extract inline code before escaping
   const inlineCodes = [];
diff --git a/src/firefox/src/ui/skill-markdown.js b/src/firefox/src/ui/skill-markdown.js
index 5e65cb0cf..2dd0f4ac6 100644
--- a/src/firefox/src/ui/skill-markdown.js
+++ b/src/firefox/src/ui/skill-markdown.js
@@ -5,7 +5,7 @@
 
 import { escapeHtml } from './utils.js';
 import { sanitizeMarkdownLinks } from './markdown-link.js';
-import { renderMarkdownHeadings, renderMarkdownTables } from './markdown-render.js';
+import { renderMarkdownHeadings, renderMarkdownTables, replaceMarkdownCodeFences } from './markdown-render.js';
 
 function renderEmphasis(text) {
   return text
@@ -38,7 +38,7 @@ function renderInlineMarkdown(value) {
 export function renderSkillMarkdown(content) {
   let text = String(content || '');
   const codeBlocks = [];
-  text = text.replace(/```[ \t]*([^`\r\n]*)\r?\n([\s\S]*?)```/g, (_match, _info, code) => {
+  text = replaceMarkdownCodeFences(text, (_info, code) => {
     const placeholder = `__SKILL_CODE_BLOCK_${codeBlocks.length}__`;
     codeBlocks.push(code);
     return placeholder;
diff --git a/test/markdown-render.mjs b/test/markdown-render.mjs
new file mode 100644
index 000000000..c3e418b2a
--- /dev/null
+++ b/test/markdown-render.mjs
@@ -0,0 +1,753 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import vm from 'node:vm';
+import { test } from 'node:test';
+
+const readUi = (build, name) => fs.readFileSync(new URL(`../src/${build}/src/ui/${name}`, import.meta.url), 'utf8');
+const panelFunction = (build, name) => {
+  const source = readUi(build, 'sidepanel.js');
+  const start = source.indexOf(`function ${name}(`);
+  assert.ok(start >= 0);
+  return source.slice(start, source.indexOf('\n}', start) + 2);
+};
+const panelFormatter = build => panelFunction(build, 'formatMarkdown');
+// Reduced reproduction of a model-authored README with same-length nested
+// fences. Keep user traces and their private page content out of the fixture.
+const readme = [
+  '# Example README', '', '## Role',
+  '```text', 'User request', '  |', '  v', 'Browser tools', '```', '',
+  '## Usage', '```javascript', 'const marker = "```";',
+  'const html = "<script>alert(1)</script>";', '```', '',
+  '### Parser notes', '```bash', 'node --test parser.test.mjs', '```', '',
+  '## License', 'See `LICENSE`.', '',
+].join('\n');
+const draft = `Here is the draft:\n\n\`\`\`markdown\n${readme}\`\`\`\n\n## Next steps\nReview it.`;
+const preContents = (html) => [...html.matchAll(/<pre><code>([\s\S]*?)<\/code><\/pre>/g)].map(match => match[1]);
+
+for (const build of ['chrome', 'firefox']) {
+  const helpers = await import(`../src/${build}/src/ui/markdown-render.js`);
+  const { sanitizeMarkdownLinks } = await import(`../src/${build}/src/ui/markdown-link.js`);
+  const { escapeHtml } = await import(`../src/${build}/src/ui/utils.js`);
+  const { renderSkillMarkdown } = await import(`../src/${build}/src/ui/skill-markdown.js`);
+  const { historyTextFromElement } = await import(`../src/${build}/src/ui/history-text.js`);
+  const formatMarkdown = vm.runInNewContext(`(${panelFormatter(build)})`, {
+    ...helpers, sanitizeMarkdownLinks, escapeHtml, t: key => key,
+    scheduleMathRender() {}, setTimeout() {},
+  });
+
+  test(`${build}: nested README remains one complete, copyable Markdown block`, () => {
+    for (const language of ['markdown', 'md', 'MARKDOWN']) {
+      const source = draft.replace('```markdown', `\`\`\`${language}`);
+      for (const [options, copyButton] of [[{ recoverNestedMarkdown: true }, true], [{ enhance: false, recoverNestedMarkdown: true }, false]]) {
+        const html = formatMarkdown(source, options);
+        assert.deepEqual(preContents(html), [helpers.escapeCodeHtml(readme)]);
+        assert.equal((html.match(/class="code-copy-btn"/g) || []).length, copyButton ? 1 : 0);
+        assert.match(html, /<h2>Next steps<\/h2>Review it\./);
+        assert.doesNotMatch(html, /<script>|<h[1-6]>Role|<br>text<br>|<br>bash<br>/i);
+      }
+    }
+  });
+
+  test(`${build}: completed Markdown keeps standard fence boundaries`, () => {
+    const source = '```markdown\n```js\nliteral\n```\nVisible prose\n```js\nindependent\n```\nAfter';
+    const html = formatMarkdown(source);
+    assert.deepEqual(preContents(html), [
+      helpers.escapeCodeHtml('```js\nliteral\n'),
+      helpers.escapeCodeHtml('independent\n'),
+    ]);
+    assert.match(html, /Visible prose/);
+    assert.match(html, /After/);
+    assert.deepEqual(preContents(renderSkillMarkdown(source)), [
+      escapeHtml('```js\nliteral\n'),
+      escapeHtml('independent\n'),
+    ]);
+  });
+
+  test(`${build}: Markdown wrappers retain longer nested fences`, () => {
+    const nested = '# Example\n\n````js\nconst value = true;\n````\n\n## After';
+    const source = `\`\`\`markdown\n${nested}\n\`\`\`\n\n## Outside`;
+    assert.deepEqual(preContents(formatMarkdown(source, { recoverNestedMarkdown: true })), [helpers.escapeCodeHtml(`${nested}\n`)]);
+    assert.match(formatMarkdown(source, { recoverNestedMarkdown: true }), /<h2>Outside<\/h2>/);
+  });
+
+  test(`${build}: Markdown wrappers retain list-prefixed nested fences`, () => {
+    const nested = '- ```js\n  code\n  ```\n- after\n';
+    const source = `\`\`\`markdown\n${nested}\`\`\`\nOutside`;
+    assert.deepEqual(preContents(formatMarkdown(source, { recoverNestedMarkdown: true })), [helpers.escapeCodeHtml(nested)]);
+    assert.match(formatMarkdown(source, { recoverNestedMarkdown: true }), /Outside/);
+  });
+
+  test(`${build}: Markdown wrappers keep over-indented fences literal`, () => {
+    const nested = '    ```js\nliteral\n';
+    const source = `\`\`\`markdown\n${nested}\`\`\`\nAfter`;
+    assert.deepEqual(preContents(formatMarkdown(source, { recoverNestedMarkdown: true })), [helpers.escapeCodeHtml(nested)]);
+    assert.match(formatMarkdown(source, { recoverNestedMarkdown: true }), /After/);
+  });
+
+  test(`${build}: Markdown wrappers retain alternate nested fence markers`, () => {
+    const nested = '~~~text\n```\n~~~\n';
+    const source = `\`\`\`markdown\n${nested}\`\`\`\nAfter`;
+    assert.deepEqual(preContents(formatMarkdown(source, { recoverNestedMarkdown: true })), [helpers.escapeCodeHtml(nested)]);
+    assert.match(formatMarkdown(source, { recoverNestedMarkdown: true }), /After/);
+  });
+
+  test(`${build}: Markdown wrappers retain distant alternate fence closers`, () => {
+    const nested = `~~~text\n${'```x\n'.repeat(64)}~~~\n`;
+    const source = `\`\`\`markdown\n${nested}\`\`\`\nAfter`;
+    assert.deepEqual(preContents(formatMarkdown(source, { recoverNestedMarkdown: true })), [helpers.escapeCodeHtml(nested)]);
+    assert.match(formatMarkdown(source, { recoverNestedMarkdown: true }), /After/);
+  });
+
+  test(`${build}: Markdown wrappers leave unmatched nested fences literal`, () => {
+    const nested = '```js\ncode\n';
+    const source = `\`\`\`\`markdown\n${nested}\`\`\`\`\nAfter`;
+    assert.deepEqual(preContents(formatMarkdown(source, { recoverNestedMarkdown: true })), [helpers.escapeCodeHtml(nested)]);
+    assert.match(formatMarkdown(source, { recoverNestedMarkdown: true }), /After/);
+  });
+
+  test(`${build}: fence length, marker and whole-line closers protect literal code`, () => {
+    const cases = [
+      ['````markdown', '```js\nconst x = 1;\n```\n', '````'],
+      ['~~~~text', '~~~\n```\n~~~~ trailing text\n', '~~~~~'],
+      ['```javascript title="sample.js"', 'const s = "```";\n~~~\n``\n``` trailing text\n', '```'],
+      ['  ```text', 'literal **bold** and [link](javascript:alert(1))\n', '   ```  '],
+      ['```text', '````js\n## Literal heading\n', '```'],
+    ];
+    for (const [open, code, close] of cases) {
+      for (const newline of ['\n', '\r\n']) {
+        const source = `${open}\n${code}${close}\n## Outside`.replaceAll('\n', newline);
+        const blocks = [];
+        const remaining = helpers.replaceMarkdownCodeFences(source, (info, value) => {
+          blocks.push({ info: info.trim(), code: value });
+          return 'BLOCK';
+        });
+        assert.deepEqual(blocks, [{ info: open.trim().replace(/^[`~]+/, ''), code: code.replaceAll('\n', newline) }]);
+        assert.equal(remaining, `BLOCK${newline}## Outside`);
+        assert.match(formatMarkdown(source), /<h2>Outside<\/h2>/);
+      }
+    }
+  });
+
+  test(`${build}: opening fence indentation is excluded from code`, () => {
+    const source = '  ~~~text\n  hello\n  ~~~\nAfter';
+    const blocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(source, (info, code) => {
+      blocks.push({ info, code });
+      return 'BLOCK';
+    }), 'BLOCK\nAfter');
+    assert.deepEqual(blocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const indentedListFence = '    - ```text\n      hello\n      ```\nAfter';
+    assert.equal(helpers.replaceMarkdownCodeFences(indentedListFence, () => 'BLOCK'), indentedListFence);
+
+    for (const indentedContainerFence of [
+      '>     > ```text\n>     > hello\n>     > ```\nAfter',
+      '>     - ```text\n>     - hello\n>     - ```\nAfter',
+    ]) {
+      assert.equal(helpers.replaceMarkdownCodeFences(indentedContainerFence, () => 'BLOCK'), indentedContainerFence);
+    }
+
+    const excessListPadding = '-     ```text\n    literal\n    ```\nAfter';
+    assert.equal(helpers.replaceMarkdownCodeFences(excessListPadding, () => 'BLOCK'), excessListPadding);
+
+    const paddedListFence = '-   ```text\n    hello\n    ```\nAfter';
+    const paddedListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(paddedListFence, (info, code) => {
+      paddedListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '-   BLOCK\nAfter');
+    assert.deepEqual(paddedListBlocks, [{ info: 'text', code: 'hello\n' }]);
+  });
+
+  test(`${build}: container-prefixed markers do not close an outer fenced block`, () => {
+    const source = '~~~markdown\n> ~~~\n- ~~~\n> ```text\n~~~\n## Outside';
+    const blocks = [];
+    const remaining = helpers.replaceMarkdownCodeFences(source, (info, code) => {
+      blocks.push({ info, code });
+      return 'BLOCK';
+    });
+    assert.deepEqual(blocks, [{ info: 'markdown', code: '> ~~~\n- ~~~\n> ```text\n' }]);
+    assert.equal(remaining, 'BLOCK\n## Outside');
+    assert.match(formatMarkdown(source), /<h2>Outside<\/h2>/);
+  });
+
+  test(`${build}: unmatched nested example fences do not steal an outer closer`, () => {
+    const source = '```markdown\n```js\nconst value = true;\n```\n\nOutside\n```\nother\n```\nAfter';
+    const blocks = [];
+    const remaining = helpers.replaceMarkdownCodeFences(source, (info, code) => {
+      blocks.push({ info, code });
+      return 'BLOCK';
+    });
+    assert.deepEqual(blocks, [
+      { info: 'markdown', code: '```js\nconst value = true;\n' },
+      { info: '', code: 'other\n' },
+    ]);
+    assert.equal(remaining, 'BLOCK\n\nOutside\nBLOCK\nAfter');
+    assert.match(formatMarkdown(source), /Outside/);
+    assert.match(formatMarkdown(source), /After/);
+    const incomplete = '```markdown\n```js\nconst value = true;\n```';
+    assert.deepEqual(preContents(formatMarkdown(incomplete, { enhance: false, recoverNestedMarkdown: true })), [escapeHtml('```js\nconst value = true;\n```')]);
+  });
+
+  test(`${build}: streamed open fences keep headings, HTML and nested examples literal`, () => {
+    for (const content of [readme, '## Heading\n<img src=x onerror=alert(1)>\n', '']) {
+      const source = `\`\`\`markdown\n${content}`;
+      const html = formatMarkdown(source, { enhance: false, recoverNestedMarkdown: true });
+      assert.deepEqual(preContents(html), [escapeHtml(content)]);
+      assert.doesNotMatch(html, /<h[1-6]>|<img |code-copy-btn/);
+    }
+    const quoted = '> ```text\n> hello\n';
+    assert.match(
+      renderSkillMarkdown(quoted),
+      /<blockquote><pre><code>hello\n<\/code><\/pre><\/blockquote>/,
+      'an unfinished quoted fence should retain its container and strip its quote marker',
+    );
+    const start = '```markdown\n';
+    for (let length = start.length; length <= start.length + readme.length; length += 1) {
+      const prefix = (start + readme).slice(0, length);
+      const blocks = preContents(formatMarkdown(prefix, { enhance: false, recoverNestedMarkdown: true }));
+      assert.equal(blocks.length, 1, `stream prefix ${length} split the document`);
+    }
+
+    const completeAlternateExample = '```markdown\n~~~text\n```\n~~~\n';
+    assert.deepEqual(
+      preContents(formatMarkdown(completeAlternateExample, { enhance: false, recoverNestedMarkdown: true })),
+      [escapeHtml('~~~text\n```\n~~~\n')],
+    );
+  });
+
+  test(`${build}: independent code blocks retain their surrounding Markdown`, () => {
+    const source = '## Start\n```js\nconst x = 1;\n```\n**Between**\n~~~bash\necho ok\n~~~\n## End';
+    const html = formatMarkdown(source);
+    assert.equal(preContents(html).length, 2);
+    assert.match(html, /syntax-keyword/);
+    assert.match(html, /<strong>Between<\/strong>/);
+    assert.match(html, /<h2>End<\/h2>/);
+    assert.match(renderSkillMarkdown(source), /<strong>Between<\/strong>/);
+    const prose = 'Use ``` inline; this is not a block.\n    ```js\nIndented example.';
+    assert.equal(helpers.replaceMarkdownCodeFences(prose, () => 'BLOCK'), prose);
+    const indentedQuote = '    > ```text\n    > literal\n    > ```';
+    assert.equal(helpers.replaceMarkdownCodeFences(indentedQuote, () => 'BLOCK'), indentedQuote);
+  });
+
+  test(`${build}: fences inside list and quote containers do not consume following prose`, () => {
+    const cases = [
+      [
+        'numbered list',
+        '1. ```python\n   value = "**literal**"\n   ```\n\n2. Start the server.',
+        /2\. Start the server\./,
+        /<ol><li><pre><code>value = &quot;\*\*literal\*\*&quot;\n<\/code><\/pre><\/li><\/ol><br><br><ol><li>Start the server\.<\/li><\/ol>/,
+      ],
+      [
+        'list marker',
+        '- ```python\n  value = "**literal**"\n  ```\n\n## Next steps\nCheck the result.',
+        /<h2>Next steps<\/h2>Check the result\./,
+        /<ul><li><pre><code>value = &quot;\*\*literal\*\*&quot;\n<\/code><\/pre><\/li><\/ul>/,
+      ],
+      [
+        'wide numbered list',
+        '10. ```text\n    value\n    ```\n\n## Next steps\nCheck the result.',
+        /<h2>Next steps<\/h2>Check the result\./,
+        /<ol><li><pre><code>value\n<\/code><\/pre><\/li><\/ol>/,
+      ],
+      [
+        'blockquote',
+        '> ```text\n> hello\n>```\n\n## Next steps\nCheck the result.',
+        /<h2>Next steps<\/h2>Check the result\./,
+        /<blockquote><pre><code>hello\n<\/code><\/pre><\/blockquote>/,
+      ],
+    ];
+    for (const [label, source, followingProse, expectedContainer] of cases) {
+      const html = formatMarkdown(source);
+      assert.equal(preContents(html).length, 1, `${label}: fence did not render as one code block`);
+      assert.doesNotMatch(html, /<strong>literal<\/strong>/, `${label}: code formatting leaked into prose`);
+      assert.match(html, followingProse, `${label}: closing fence consumed following prose`);
+      const historyHtml = renderSkillMarkdown(source);
+      assert.match(historyHtml, expectedContainer, `${label}: code block lost its Markdown container`);
+      assert.doesNotMatch(historyHtml, /&gt; hello/, `${label}: blockquote marker leaked into code`);
+    }
+  });
+
+  test(`${build}: over-indented list code does not close a contained fence`, () => {
+    const source = '- ```text\n      ```\n  value\n  ```\nAfter';
+    const blocks = [];
+    const remaining = helpers.replaceMarkdownCodeFences(source, (info, code) => {
+      blocks.push({ info, code });
+      return 'BLOCK';
+    });
+    assert.deepEqual(blocks, [{ info: 'text', code: '    ```\nvalue\n' }]);
+    assert.equal(remaining, '- BLOCK\nAfter');
+    assert.match(formatMarkdown(source), /After/);
+
+    const allowedCloserIndent = '- ```text\n  hello\n   ```\nAfter';
+    const allowedCloserBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(allowedCloserIndent, (info, code) => {
+      allowedCloserBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- BLOCK\nAfter');
+    assert.deepEqual(allowedCloserBlocks, [{ info: 'text', code: 'hello\n' }]);
+  });
+
+  test(`${build}: list continuation fences use the preceding list indent`, () => {
+    const cases = [
+      ['10. Step\n    ```js\n    const value = true;\n    ```\nAfter', '10. Step\n    BLOCK\nAfter'],
+      ['10. Step\n    continuation\n    ```js\n    const value = true;\n    ```\nAfter', '10. Step\n    continuation\n    BLOCK\nAfter'],
+      ['> 10. Step\n>     ```js\n>     const value = true;\n>     ```\n> After', '> 10. Step\n>     BLOCK\n> After'],
+      ['- > - item\n  >     ```js\n  >     const value = true;\n  >     ```\nAfter', '- > - item\n  >     BLOCK\nAfter'],
+    ];
+    for (const [source, expected] of cases) {
+      const blocks = [];
+      const remaining = helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        blocks.push({ info, code });
+        return 'BLOCK';
+      });
+      assert.deepEqual(blocks, [{ info: 'js', code: 'const value = true;\n' }]);
+      assert.equal(remaining, expected);
+      assert.equal(preContents(formatMarkdown(source)).length, 1);
+    }
+    assert.match(renderSkillMarkdown(cases[2][0]), /<blockquote>[\s\S]*<pre><code>const value = true;\n<\/code><\/pre>/);
+
+    const shortIndent = '- item\n  ```text\n  hello\n\nAfter';
+    const shortBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(shortIndent, (info, code) => {
+      shortBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- item\n  BLOCK\nAfter');
+    assert.deepEqual(shortBlocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const extraIndent = '10. item\n    continuation\n       ```js\n       code\n       ```';
+    const extraIndentBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(extraIndent, (info, code) => {
+      extraIndentBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '10. item\n    continuation\n       BLOCK');
+    assert.deepEqual(extraIndentBlocks, [{ info: 'js', code: 'code\n' }]);
+  });
+
+  test(`${build}: fences in nested list and quote containers preserve following content`, () => {
+    const cases = [
+      ['- - ```js\n    const x = 1;\n    ```\n    **After**', '- - BLOCK\n    **After**'],
+      ['- > ```js\n  > const x = 1;\n  > ```\n  After', '- > BLOCK\n  After'],
+    ];
+    for (const [source, expected] of cases) {
+      const blocks = [];
+      const remaining = helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        blocks.push({ info, code });
+        return 'BLOCK';
+      });
+      assert.deepEqual(blocks, [{ info: 'js', code: 'const x = 1;\n' }]);
+      assert.equal(remaining, expected);
+      assert.equal(preContents(formatMarkdown(source)).length, 1);
+    }
+
+    const listQuote = '- > ```text\n  >   hello\n  > ```';
+    const listQuoteBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(listQuote, (info, code) => {
+      listQuoteBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- > BLOCK');
+    assert.deepEqual(listQuoteBlocks, [{ info: 'text', code: '  hello\n' }]);
+
+    const nestedQuoteList = '> - > ```js\n>   > code\n>   > ```';
+    const nestedQuoteListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(nestedQuoteList, (info, code) => {
+      nestedQuoteListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> - > BLOCK');
+    assert.deepEqual(nestedQuoteListBlocks, [{ info: 'js', code: 'code\n' }]);
+  });
+
+  test(`${build}: unfinished container fences stop at their container boundary`, () => {
+    const cases = [
+      ['> ```text\n> hello\n\nOutside', '> BLOCK\nOutside'],
+      ['- ```text\n  hello\n\n- Next', '- BLOCK\n- Next'],
+    ];
+    for (const [source, expected] of cases) {
+      const blocks = [];
+      const remaining = helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        blocks.push({ info, code });
+        return 'BLOCK';
+      });
+      assert.deepEqual(blocks, [{ info: 'text', code: 'hello\n' }]);
+      assert.equal(remaining, expected);
+      assert.equal(preContents(formatMarkdown(source)).length, 1);
+    }
+    const siblingUnfinishedFences = '- item\n  ```js\n  one\n- next\n  ```\n  two\nOutside';
+    const siblingBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(siblingUnfinishedFences, (info, code) => {
+      siblingBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- item\n  BLOCK\n- next\n  BLOCK\nOutside');
+    assert.deepEqual(siblingBlocks, [{ info: 'js', code: 'one\n' }, { info: '', code: 'two\n' }]);
+    assert.match(formatMarkdown(cases[0][0]), /Outside/);
+    assert.match(formatMarkdown(cases[1][0]), /Next/);
+    const unfinishedList = '- ```text\n  hello\n\n  again';
+    const listBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(unfinishedList, (info, code) => {
+      listBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- BLOCK');
+    assert.deepEqual(listBlocks, [{ info: 'text', code: 'hello\n\nagain' }]);
+
+    const quoteListBoundary = '  > - ```text\n  >   hello\n  > Outside\n\nAfter';
+    const quoteListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quoteListBoundary, (info, code) => {
+      quoteListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '  > - BLOCK\n  > Outside\n\nAfter');
+    assert.deepEqual(quoteListBlocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const quoteBlank = '> ```text\n> hello\n>\n>\n> again\n> ```';
+    const quoteBlankBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quoteBlank, (info, code) => {
+      quoteBlankBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK');
+    assert.deepEqual(quoteBlankBlocks, [{ info: 'text', code: 'hello\n\n\nagain\n' }]);
+
+    const unprefixedQuoteBreak = '> ```text\n> first\n\n> second\n> ```\nAfter';
+    const unprefixedQuoteBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(unprefixedQuoteBreak, (info, code) => {
+      unprefixedQuoteBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\n> second\n> BLOCK\nAfter');
+    assert.deepEqual(unprefixedQuoteBlocks, [{ info: 'text', code: 'first\n' }, { info: '', code: '' }]);
+
+    const mixedQuoteListBreak = '> - ```text\n>   first\n\n>   second\n>   ```\nAfter';
+    const mixedQuoteListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(mixedQuoteListBreak, (info, code) => {
+      mixedQuoteListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> - BLOCK\n>   second\n>   BLOCK\nAfter');
+    assert.deepEqual(mixedQuoteListBlocks, [{ info: 'text', code: 'first\n' }, { info: '', code: '' }]);
+
+    const quotedBlankReset = '> ```text\n> first\n\n>\n> second\n> ```\nAfter';
+    const quotedBlankResetBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quotedBlankReset, (info, code) => {
+      quotedBlankResetBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\n>\n> second\n> BLOCK\nAfter');
+    assert.deepEqual(quotedBlankResetBlocks, [{ info: 'text', code: 'first\n' }, { info: '', code: '' }]);
+
+    const wideQuotedListBlank = '10. > ```text\n    > hello\n    >\n    > again\n    > ```';
+    const wideQuotedListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(wideQuotedListBlank, (info, code) => {
+      wideQuotedListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '10. > BLOCK');
+    assert.deepEqual(wideQuotedListBlocks, [{ info: 'text', code: 'hello\n\nagain\n' }]);
+
+    const quoteListContinuation = '- item\n  > ```text\n  > hello\n  > ```\nAfter';
+    const quoteListContinuationBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quoteListContinuation, (info, code) => {
+      quoteListContinuationBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- item\n  > BLOCK\nAfter');
+    assert.deepEqual(quoteListContinuationBlocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const lazyOrderedParagraph = '- item\n2. continuation\n  ```text\n  hi\nOutside';
+    const lazyOrderedParagraphBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(lazyOrderedParagraph, (info, code) => {
+      lazyOrderedParagraphBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- item\n2. continuation\n  BLOCK\nOutside');
+    assert.deepEqual(lazyOrderedParagraphBlocks, [{ info: 'text', code: 'hi\n' }]);
+
+    for (const continuation of ['2.', '2. ', '1.', '1. ', '---text', '-_*', '<span>inline</span>']) {
+      const source = `- item\n${continuation}\n  \`\`\`text\n  hi\nOutside`;
+      const blocks = [];
+      assert.equal(helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        blocks.push({ info, code });
+        return 'BLOCK';
+      }), `- item\n${continuation}\n  BLOCK\nOutside`);
+      assert.deepEqual(blocks, [{ info: 'text', code: 'hi\n' }]);
+    }
+
+    for (const marker of ['-', '- ', '*', '+\t']) {
+      const source = `10. item\n${marker}\n    \`\`\`text\n    hi\n  outside`;
+      const blocks = [];
+      assert.equal(helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        blocks.push({ info, code });
+        return 'BLOCK';
+      }), `10. item\n${marker}\n    BLOCK\n  outside`);
+      assert.deepEqual(blocks, [{ info: 'text', code: 'hi\n' }]);
+    }
+
+    for (const interruptingHtml of ['<!-- done -->', '<?done?>', '<!DOCTYPE html>', '<![CDATA[x]]>', '<div>', '</div>']) {
+      const source = `- item\n${interruptingHtml}\n  \`\`\`text\n  hi\nOutside`;
+      const blocks = [];
+      assert.equal(helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        blocks.push({ info, code });
+        return 'BLOCK';
+      }), `- item\n${interruptingHtml}\nBLOCK`);
+      assert.deepEqual(blocks, [{ info: 'text', code: 'hi\nOutside' }]);
+    }
+
+    for (const continuation of ['lazy continuation', '2. continuation', '2.', '---text']) {
+      const source = `> - item\n> ${continuation}\n>   \`\`\`text\n>   hi\n> Outside`;
+      const blocks = [];
+      assert.equal(helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        blocks.push({ info, code });
+        return 'BLOCK';
+      }), `> - item\n> ${continuation}\n>   BLOCK\n> Outside`);
+      assert.deepEqual(blocks, [{ info: 'text', code: 'hi\n' }]);
+    }
+
+    const noCloser = '> ```text\n> inside\nOutside';
+    const noCloserBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(noCloser, (info, code) => {
+      noCloserBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\nOutside');
+    assert.deepEqual(noCloserBlocks, [{ info: 'text', code: 'inside\n' }]);
+
+    for (const [source, expected] of [
+      ['> ```text\nOutside', '> BLOCK\nOutside'],
+      ['- ```text\nOutside', '- BLOCK\nOutside'],
+    ]) {
+      const emptyBlocks = [];
+      assert.equal(helpers.replaceMarkdownCodeFences(source, (info, code) => {
+        emptyBlocks.push({ info, code });
+        return 'BLOCK';
+      }), expected);
+      assert.deepEqual(emptyBlocks, [{ info: 'text', code: '' }]);
+    }
+
+    const emptyListItem = '-\n  ```text\n  hi\nOutside';
+    const emptyListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(emptyListItem, (info, code) => {
+      emptyListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '-\n  BLOCK\nOutside');
+    assert.deepEqual(emptyListBlocks, [{ info: 'text', code: 'hi\n' }]);
+
+    const emptyListBoundary = '-\n  ```text\n Outside';
+    const emptyListBoundaryBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(emptyListBoundary, (info, code) => {
+      emptyListBoundaryBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '-\n  BLOCK\n Outside');
+    assert.deepEqual(emptyListBoundaryBlocks, [{ info: 'text', code: '' }]);
+
+    const trailingQuoteBlank = '> ```text\n> hello\n>\n';
+    const trailingQuoteBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(trailingQuoteBlank, (info, code) => {
+      trailingQuoteBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK');
+    assert.deepEqual(trailingQuoteBlocks, [{ info: 'text', code: 'hello\n\n' }]);
+
+    const unprefixedTrailingBlank = '> ~~~text\n> hello\n\n';
+    const unprefixedTrailingBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(unprefixedTrailingBlank, (info, code) => {
+      unprefixedTrailingBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\n');
+    assert.deepEqual(unprefixedTrailingBlocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const quotedBlankBeforeProse = '> ~~~text\n> hello\n>\nOutside';
+    const quotedBlankBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quotedBlankBeforeProse, (info, code) => {
+      quotedBlankBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\nOutside');
+    assert.deepEqual(quotedBlankBlocks, [{ info: 'text', code: 'hello\n\n' }]);
+
+    const escapedQuote = '> ```text\n> inside\nOutside\n> ```\nAfter';
+    const quoteBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(escapedQuote, (info, code) => {
+      quoteBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\nOutside\n> BLOCK\nAfter');
+    assert.deepEqual(quoteBlocks, [{ info: 'text', code: 'inside\n' }, { info: '', code: '' }]);
+
+    const laterBlock = '> ```text\n> inside\nOutside\n```js\ncode\n```\nAfter';
+    const laterBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(laterBlock, (info, code) => {
+      laterBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\nOutside\nBLOCK\nAfter');
+    assert.deepEqual(laterBlocks, [
+      { info: 'text', code: 'inside\n' },
+      { info: 'js', code: 'code\n' },
+    ]);
+
+    const adjacentBlock = '> ```text\n> inside\n```js\ncode\n```\nAfter';
+    const adjacentBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(adjacentBlock, (info, code) => {
+      adjacentBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK\nBLOCK\nAfter');
+    assert.deepEqual(adjacentBlocks, [
+      { info: 'text', code: 'inside\n' },
+      { info: 'js', code: 'code\n' },
+    ]);
+
+    const quotedList = '> - ```text\n>   hello\n>\n>   again\n>   ```';
+    const quotedListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quotedList, (info, code) => {
+      quotedListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> - BLOCK');
+    assert.deepEqual(quotedListBlocks, [{ info: 'text', code: 'hello\n\nagain\n' }]);
+  });
+
+  test(`${build}: tab-indented list fences use visual indentation columns`, () => {
+    const source = '-\t```text\n\tvalue\n\t```\nAfter';
+    const blocks = [];
+    const remaining = helpers.replaceMarkdownCodeFences(source, (info, code) => {
+      blocks.push({ info, code });
+      return 'BLOCK';
+    });
+    assert.deepEqual(blocks, [{ info: 'text', code: 'value\n' }]);
+    assert.equal(remaining, '-\tBLOCK\nAfter');
+    assert.equal(helpers.replaceMarkdownCodeFences('\t```js\nIndented example.', () => 'BLOCK'), '\t```js\nIndented example.');
+
+    const quotedList = '> -\t```text\n>   hello\n>   ```\nAfter';
+    const quotedListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quotedList, (info, code) => {
+      quotedListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> -\tBLOCK\nAfter');
+    assert.deepEqual(quotedListBlocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const quotedTab = '>   ~~~text\n> \thello\n>   ~~~';
+    const quotedTabBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(quotedTab, (info, code) => {
+      quotedTabBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> BLOCK');
+    assert.deepEqual(quotedTabBlocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const nestedQuotedList = '- > -\t```text\n  > \thello\n  > \t```\nAfter';
+    const nestedQuotedListBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(nestedQuotedList, (info, code) => {
+      nestedQuotedListBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '- > -\tBLOCK\nAfter');
+    assert.deepEqual(nestedQuotedListBlocks, [{ info: 'text', code: 'hello\n' }]);
+
+    const tabbedNestedQuote = '> \t> ```text\n> \t> hello\n> \t> ```\nAfter';
+    const tabbedNestedQuoteBlocks = [];
+    assert.equal(helpers.replaceMarkdownCodeFences(tabbedNestedQuote, (info, code) => {
+      tabbedNestedQuoteBlocks.push({ info, code });
+      return 'BLOCK';
+    }), '> \t> BLOCK\nAfter');
+    assert.deepEqual(tabbedNestedQuoteBlocks, [{ info: 'text', code: 'hello\n' }]);
+  });
+
+  test(`${build}: saved history uses an outer fence longer than all literal backticks`, () => {
+    const text = value => ({ nodeType: 3, nodeValue: value });
+    const element = (tagName, ...childNodes) => ({ nodeType: 1, tagName, childNodes });
+    for (const code of [readme, '````markdown\n```js\nconst x = 1;\n```\n````\n']) {
+      const pre = element('PRE', element('CODE', text(code)));
+      pre.parentElement = { querySelector: () => ({ textContent: 'markdown' }) };
+      const saved = historyTextFromElement(element('DIV', pre));
+      const firstFence = saved.match(/^(`+) markdown/)[1];
+      assert.ok([...code.matchAll(/`+/g)].every(match => match[0].length < firstFence.length));
+      assert.deepEqual(preContents(renderSkillMarkdown(saved)), [escapeHtml(code)]);
+      assert.deepEqual(preContents(formatMarkdown(saved)), [helpers.escapeCodeHtml(code)]);
+    }
+  });
+
+  test(`${build}: history uses tilde fences for language labels containing backticks`, () => {
+    const text = value => ({ nodeType: 3, nodeValue: value });
+    const element = (tagName, ...childNodes) => ({ nodeType: 1, tagName, childNodes });
+    const code = '~~~\nconst value = true;\n';
+    const pre = element('PRE', element('CODE', text(code)));
+    pre.parentElement = { querySelector: () => ({ textContent: '`javascript`' }) };
+    const saved = historyTextFromElement(element('DIV', pre));
+    assert.match(saved, /^~~~~ `javascript`\n~~~\nconst value = true;\n~~~~$/);
+    const source = `${saved}\n## After`;
+    assert.deepEqual(preContents(formatMarkdown(source)), [helpers.escapeCodeHtml(code)]);
+    assert.match(formatMarkdown(source), /<h2>After<\/h2>/);
+  });
+
+  test(`${build}: history keeps tilde-prefixed labels separate from the fence`, () => {
+    const text = value => ({ nodeType: 3, nodeValue: value });
+    const element = (tagName, ...childNodes) => ({ nodeType: 1, tagName, childNodes });
+    const code = 'const value = true;\n';
+    const pre = element('PRE', element('CODE', text(code)));
+    pre.parentElement = { querySelector: () => ({ textContent: '~lang`x' }) };
+    const saved = historyTextFromElement(element('DIV', pre));
+    assert.match(saved, /^~~~ ~lang`x\nconst value = true;\n~~~$/);
+    const source = `${saved}\n## After`;
+    assert.deepEqual(preContents(formatMarkdown(source)), [helpers.escapeCodeHtml(code)]);
+    assert.match(formatMarkdown(source), /<h2>After<\/h2>/);
+  });
+
+  // Opt-in native DOM checks: WEBBRAIN_MARKDOWN_DOM=1 npm run test:markdown.
+  if (process.env.WEBBRAIN_MARKDOWN_DOM === '1') test(`${build}: browser render, Copy and history round trip`, async () => {
+    const { chromium, firefox } = await import('playwright');
+    const browser = await (build === 'chrome' ? chromium : firefox).launch({ headless: true });
+    try {
+      const page = await browser.newPage({ viewport: { width: 480, height: 1000 } });
+      await page.route('http://markdown.test/**', async route => {
+        const name = new URL(route.request().url()).pathname.slice(1);
+        if (/^[\w-]+\.js$/.test(name)) {
+          await route.fulfill({ contentType: 'text/javascript', body: readUi(build, name) });
+        } else {
+          await route.fulfill({ contentType: 'text/html', body: '<html data-theme="light"><body><div class="message assistant"><div class="message-content" id="message"></div></div><div id="history"></div></body></html>' });
+        }
+      });
+      await page.goto('http://markdown.test/');
+      await page.addStyleTag({ content: fs.readFileSync(new URL(`../src/${build}/styles/sidepanel.css`, import.meta.url), 'utf8') });
+      const result = await page.evaluate(async ({ formatter, terminalRenderer, source, expected }) => {
+        const helpers = await import('/markdown-render.js');
+        const { sanitizeMarkdownLinks } = await import('/markdown-link.js');
+        const { escapeHtml } = await import('/utils.js');
+        const { historyTextFromElement } = await import('/history-text.js');
+        const { renderSkillMarkdown } = await import('/skill-markdown.js');
+        const dependencies = { ...helpers, sanitizeMarkdownLinks, escapeHtml, t: key => key, scheduleMathRender() {} };
+        const format = new Function(...Object.keys(dependencies), `return (${formatter})`)(...Object.values(dependencies));
+        let copied = null;
+        Object.defineProperty(navigator, 'clipboard', { value: { writeText: async text => { copied = text; } } });
+        const message = document.querySelector('#message');
+        message.innerHTML = format(source, { recoverNestedMarkdown: true });
+        const streamed = message.querySelector('pre code').textContent;
+        const updateDependencies = {
+          formatMarkdown: format,
+          isStoppedByUserStatus: () => false,
+          parseCostAllowanceError: () => false,
+          renderSubscribeError: () => false,
+          getStreamedAssistantText: () => source,
+          hasStreamedAssistantText: () => true,
+          clearStreamedAssistantText() {},
+          streamedAssistantTextByEl: new Map(),
+          addMessageCopyButton() {},
+          verboseMode: false,
+          document,
+        };
+        const renderTerminal = new Function(...Object.keys(updateDependencies), `return (${terminalRenderer})`)(...Object.values(updateDependencies));
+        const assistantEl = { querySelector: selector => selector === '.message-text' ? message : {} };
+        renderTerminal(assistantEl, source);
+        const terminalBlocks = message.querySelectorAll('pre').length;
+        renderTerminal(assistantEl, source, { replace: true });
+        const replacedBlocks = message.querySelectorAll('pre').length;
+        await new Promise(resolve => setTimeout(resolve, 20));
+        message.querySelector('.code-copy-btn').click();
+        await Promise.resolve();
+        const saved = historyTextFromElement(message);
+        const history = document.querySelector('#history');
+        history.innerHTML = renderSkillMarkdown(saved);
+        return {
+          blocks: message.querySelectorAll('pre').length,
+          terminalBlocks,
+          replacedBlocks,
+          streamedMatches: streamed === expected,
+          copiedMatches: copied === expected,
+          historyMatches: history.querySelector('pre code').textContent === expected,
+          historyBlocks: history.querySelectorAll('pre').length,
+          nextHeading: message.querySelector('h2').textContent,
+          unsafeElements: message.querySelectorAll('script, img').length,
+        };
+      }, { formatter: panelFormatter(build), terminalRenderer: panelFunction(build, 'renderAssistantTextUpdate'), source: draft, expected: readme });
+      assert.deepEqual(result, { blocks: 1, terminalBlocks: 1, replacedBlocks: 1, streamedMatches: true, copiedMatches: true, historyMatches: true, historyBlocks: 1, nextHeading: 'Next steps', unsafeElements: 0 });
+      if (process.env.WEBBRAIN_MARKDOWN_SCREENSHOT_DIR) {
+        await page.screenshot({ path: `${process.env.WEBBRAIN_MARKDOWN_SCREENSHOT_DIR}/${build}-markdown.png`, fullPage: true });
+      }
+    } finally {
+      await browser.close();
+    }
+  });
+}
diff --git a/test/run.js b/test/run.js
index 4faa4ce7b..14cf64a86 100644
--- a/test/run.js
+++ b/test/run.js
@@ -21917,7 +21917,7 @@ test('sidepanels wire highlighting and heading rendering into fenced Markdown',
   ]) {
     const panel = fs.readFileSync(path.join(ROOT, panelRel), 'utf8');
     const css = fs.readFileSync(path.join(ROOT, cssRel), 'utf8');
-    assert.match(panel, /import \{ codeFenceLanguage, highlightCode, renderMarkdownHeadings, renderMarkdownTables \} from '\.\/markdown-render\.js';/, `${label}: renderer helpers should be imported`);
+    assert.match(panel, /import \{ codeFenceLanguage, highlightCode, renderMarkdownHeadings, renderMarkdownTables, replaceMarkdownCodeFences \} from '\.\/markdown-render\.js';/, `${label}: renderer helpers should be imported`);
     assert.match(panel, /const lang = codeFenceLanguage\(info\);/, `${label}: fenced code should tolerate metadata after its language token`);
     assert.match(panel, /const highlighted = enhance \? highlightCode\(block\.code, block\.lang\) : escapeHtml\(block\.code\);/, `${label}: completed fenced code should be highlighted by its language while live code stays lightweight`);
     assert.match(panel, /text = renderMarkdownTables\(text\);\s*text = renderMarkdownHeadings\(text\);/, `${label}: pipe tables must render before headings swallow the following newline`);