From 7fce349091a6a2da00de54c1a3837d35b743f04e Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 19:39:20 +0800
Subject: [PATCH 1/9] feat(web): render LaTeX math in chat via KaTeX

---
 .changeset/web-katex-math.md              |  5 +++++
 apps/kimi-web/package.json                |  1 +
 apps/kimi-web/src/components/Markdown.vue | 22 +++++++++++++++++++++-
 pnpm-lock.yaml                            |  3 +++
 4 files changed, 30 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/web-katex-math.md

diff --git a/.changeset/web-katex-math.md b/.changeset/web-katex-math.md
new file mode 100644
index 0000000000..5a66092530
--- /dev/null
+++ b/.changeset/web-katex-math.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX.
diff --git a/apps/kimi-web/package.json b/apps/kimi-web/package.json
index c3a262adab..0f3c60f436 100644
--- a/apps/kimi-web/package.json
+++ b/apps/kimi-web/package.json
@@ -16,6 +16,7 @@
     "@fontsource-variable/jetbrains-mono": "^5.2.8",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
+    "katex": "^0.16.22",
     "markstream-vue": "1.0.3",
     "shiki": "^4.2.0",
     "stream-markdown": "^0.0.16",
diff --git a/apps/kimi-web/src/components/Markdown.vue b/apps/kimi-web/src/components/Markdown.vue
index 1477213543..4138afe962 100644
--- a/apps/kimi-web/src/components/Markdown.vue
+++ b/apps/kimi-web/src/components/Markdown.vue
@@ -2,7 +2,7 @@
 <script setup lang="ts">
 import { computed, inject, nextTick, onMounted, onUnmounted, reactive, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
-import { MarkdownRender } from 'markstream-vue';
+import { MarkdownRender, enableKatex } from 'markstream-vue';
 import { useIsDark } from '../composables/useIsDark';
 import type { FilePreviewRequest } from '../types';
 import { collectFilePathAliases, findFilePathLinks } from '../lib/filePathLinks';
@@ -12,6 +12,13 @@ import { markdownRenderPlan } from '../lib/markdownPerformance';
 // Terminal Pro. Importing the same file from multiple components is a no-op
 // after the first (Vite dedups the CSS import).
 import 'markstream-vue/index.px.css';
+// KaTeX math: markstream renders `$…$` / `$$…$$` only after the optional katex
+// peer is enabled, and its stylesheet (+ bundled fonts) is what gives formulas
+// their layout. enableKatex() registers the default `import('katex')` loader; it
+// runs once on first import of this module and is safe at module scope. Without
+// the CSS the math renders unstyled, so both must travel together.
+import 'katex/dist/katex.min.css';
+enableKatex();
 
 const { t } = useI18n();
 
@@ -578,6 +585,19 @@ function copyDiff(code: string, idx: number) {
   text-decoration: underline;
 }
 
+/* KaTeX math. Colour already inherits (--text) since KaTeX draws with
+   currentColor, so the only skinning needed is layout: let a wide display
+   formula scroll inside its own box instead of overflowing the chat column and
+   breaking the mobile layout. Inline math stays in the text flow. */
+.md :deep(.katex-display) {
+  overflow-x: auto;
+  overflow-y: hidden;
+  /* room for the horizontal scrollbar so it doesn't clip the bottom of the
+     formula (e.g. integral/sum subscripts) */
+  padding: 2px 0 6px;
+  margin: 0.6em 0;
+}
+
 /* Blockquote */
 .md :deep(blockquote) {
   margin: 0.5em 0;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b9d2dff47d..615cc71a90 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -163,6 +163,9 @@ importers:
       '@xterm/xterm':
         specifier: ^6.0.0
         version: 6.0.0
+      katex:
+        specifier: ^0.16.22
+        version: 0.16.47
       markstream-vue:
         specifier: 1.0.3
         version: 1.0.3(katex@0.16.47)(mermaid@11.15.0)(stream-markdown@0.0.16(react@19.2.5)(shiki@4.2.0)(vue@3.5.35(typescript@6.0.2)))(vue-i18n@11.4.5(vue@3.5.35(typescript@6.0.2)))(vue@3.5.35(typescript@6.0.2))

From bdb5c351c95db8f8160f645963d01aa0336780d6 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 21:56:44 +0800
Subject: [PATCH 2/9] fix(web): keep literal prose dollars out of KaTeX inline
 math
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Enabling KaTeX turned plain prose with two dollar-prefixed tokens
(`Check $PATH before $HOME`, `costs $5 and $10`) into a single
inline formula, since markstream's $…$ tokenizer has no
"no whitespace inside the delimiters" rule.

Add a postTransformTokens guard that turns a single-$ inline span back
into literal text when its content starts or ends with whitespace. Real
inline math is written tight (`$E=mc^2$`, `$\frac{1}{2}$`), while
the prose false-positives always have whitespace inside the delimiters,
so this keeps inline/block math working while leaving prices, env vars,
and ranges as readable text. Code spans are already excluded by the
tokenizer, and running on the flat token stream also covers dollars
nested inside lists and blockquotes.

Addresses the Codex review comment on PR #1035.
---
 .changeset/web-katex-math.md                  |  2 +-
 .../kimi-web/src/components/chat/Markdown.vue |  7 +++
 apps/kimi-web/src/lib/mathDelimiters.ts       | 39 ++++++++++++
 apps/kimi-web/test/lib-logic.test.ts          | 59 +++++++++++++++++++
 4 files changed, 106 insertions(+), 1 deletion(-)
 create mode 100644 apps/kimi-web/src/lib/mathDelimiters.ts

diff --git a/.changeset/web-katex-math.md b/.changeset/web-katex-math.md
index 5a66092530..754a9ccb2e 100644
--- a/.changeset/web-katex-math.md
+++ b/.changeset/web-katex-math.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": patch
 ---
 
-Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX.
+Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX. Plain prose dollars (e.g. `$PATH`, `$5 and $10`) are kept as literal text instead of being swallowed as a formula.
diff --git a/apps/kimi-web/src/components/chat/Markdown.vue b/apps/kimi-web/src/components/chat/Markdown.vue
index c763d5363b..e95b5bc23b 100644
--- a/apps/kimi-web/src/components/chat/Markdown.vue
+++ b/apps/kimi-web/src/components/chat/Markdown.vue
@@ -3,10 +3,12 @@
 import { computed, inject, nextTick, onMounted, onUnmounted, reactive, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { MarkdownRender, enableKatex } from 'markstream-vue';
+import type { ParseOptions } from 'markstream-vue';
 import { useIsDark } from '../../composables/useIsDark';
 import type { FilePreviewRequest } from '../../types';
 import { collectFilePathAliases, findFilePathLinks } from '../../lib/filePathLinks';
 import { markdownRenderPlan } from '../../lib/markdownPerformance';
+import { guardLiteralDollarMath } from '../../lib/mathDelimiters';
 // px-based CSS build (our app is px, not rem). Imported here so the styles
 // load wherever Markdown is used; scoped overrides below re-skin it to
 // Terminal Pro. Importing the same file from multiple components is a no-op
@@ -20,6 +22,10 @@ import 'markstream-vue/index.px.css';
 import 'katex/dist/katex.min.css';
 enableKatex();
 
+// Keep `$…$` inline math but stop two prose dollars (`$PATH before $HOME`,
+// `$5 and $10`) from being swallowed as one formula. See mathDelimiters.ts.
+const parseOptions: ParseOptions = { postTransformTokens: guardLiteralDollarMath };
+
 const { t } = useI18n();
 
 const resolveImage = inject<(src: string) => Promise<string>>('resolveImage');
@@ -363,6 +369,7 @@ function copyDiff(code: string, idx: number) {
       <MarkdownRender
         v-if="seg.kind === 'md'"
         :content="seg.text"
+        :parse-options="parseOptions"
         mode="chat"
         :code-renderer="renderPlan.codeRenderer"
         :is-dark="isDark"
diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
new file mode 100644
index 0000000000..2fbba7cbf8
--- /dev/null
+++ b/apps/kimi-web/src/lib/mathDelimiters.ts
@@ -0,0 +1,39 @@
+import type { MarkdownToken } from 'markstream-vue';
+
+/**
+ * Guard ordinary prose dollars from being rendered as KaTeX inline math.
+ *
+ * markstream renders `$…$` as inline math once KaTeX is enabled, but its
+ * tokenizer has no "no whitespace inside the delimiters" rule, so two
+ * dollar-prefixed tokens in plain prose get swallowed as one formula —
+ * `Check $PATH before $HOME` and `costs $5 and $10` both render as math
+ * instead of readable text.
+ *
+ * Real inline math is written tight (`$E=mc^2$`, `$\frac{1}{2}$`), while the
+ * prose false-positives always have whitespace inside the delimiters
+ * (`PATH before `, `5 and `). So a single-`$` span whose content starts or
+ * ends with whitespace is treated as literal `$…$` text again. Block `$$…$$`
+ * math and tight inline math are left untouched.
+ *
+ * This runs on the flat markdown-it token stream, so it also covers dollars
+ * nested inside lists and blockquotes (their `inline` tokens sit at the top
+ * level of the stream). Code spans are already excluded by the tokenizer.
+ */
+export function guardLiteralDollarMath(tokens: MarkdownToken[]): MarkdownToken[] {
+  for (const token of tokens) {
+    if (token.type !== 'inline' || !token.children) continue;
+    for (const child of token.children) {
+      if (
+        child.type === 'math_inline' &&
+        child.markup === '$' &&
+        /^\s|\s$/.test(child.content ?? '')
+      ) {
+        child.type = 'text';
+        child.markup = '';
+        child.content = `$${child.content ?? ''}$`;
+        child.children = null;
+      }
+    }
+  }
+  return tokens;
+}
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index 02a2392b82..e4d8824d64 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -1,9 +1,11 @@
+import { getMarkdown, parseMarkdownToStructure } from 'markstream-vue';
 import { describe, expect, it } from 'vitest';
 import {
   collectFilePathAliases,
   findFilePathLinks,
   parseFilePathLinkCandidate,
 } from '../src/lib/filePathLinks';
+import { guardLiteralDollarMath } from '../src/lib/mathDelimiters';
 import { parseDiff } from '../src/lib/parseDiff';
 import { normalizeToolName, toolSummary } from '../src/lib/toolMeta';
 
@@ -76,3 +78,60 @@ describe('toolMeta', () => {
     ).toBe('example.com/path');
   });
 });
+
+// Flatten a parsed node tree into leaf-ish `{type, content}` entries so the
+// assertions below don't care about paragraph/blockquote/list nesting.
+type FlatNode = { type: string; content?: string };
+function flatten(nodes: unknown[]): FlatNode[] {
+  const out: FlatNode[] = [];
+  for (const raw of nodes) {
+    const n = raw as { type: string; content?: string; children?: unknown[] };
+    if (n.children?.length) out.push(...flatten(n.children));
+    else out.push({ type: n.type, content: n.content });
+  }
+  return out;
+}
+
+describe('guardLiteralDollarMath', () => {
+  const md = getMarkdown('guardLiteralDollarMath');
+  const render = (text: string) =>
+    flatten(parseMarkdownToStructure(text, md, { postTransformTokens: guardLiteralDollarMath }));
+  const types = (text: string) => render(text).map((n) => n.type);
+
+  it('keeps literal-dollar prose as text, not inline math', () => {
+    for (const text of ['Check $PATH before $HOME', 'costs $5 and $10']) {
+      expect(types(text)).not.toContain('math_inline');
+      expect(render(text)).toEqual([{ type: 'text', content: text }]);
+    }
+  });
+
+  it('still renders tight inline math and block math', () => {
+    expect(render('Einstein $E=mc^2$ famous')).toEqual([
+      { type: 'text', content: 'Einstein ' },
+      { type: 'math_inline', content: 'E=mc^2' },
+      { type: 'text', content: ' famous' },
+    ]);
+    expect(render('inline $\\frac{1}{2}$ math').map((n) => n.type)).toContain('math_inline');
+    expect(render('$$a^2 + b^2 = c^2$$')).toEqual([
+      { type: 'math_block', content: 'a^2 + b^2 = c^2' },
+    ]);
+  });
+
+  it('guards prose dollars nested inside lists and blockquotes', () => {
+    expect(types('- $5 and $10')).not.toContain('math_inline');
+    expect(types('> $PATH before $HOME')).not.toContain('math_inline');
+  });
+
+  it('leaves code spans and a single unmatched dollar untouched', () => {
+    expect(types('code `$5 and $10` here')).not.toContain('math_inline');
+    expect(render('it costs $5')).toEqual([{ type: 'text', content: 'it costs $5' }]);
+  });
+
+  it('keeps multiple real inline math spans on one line', () => {
+    expect(render('$A$ and $B$').map((n) => n.type)).toEqual([
+      'math_inline',
+      'text',
+      'math_inline',
+    ]);
+  });
+});

From 08deac28841b837dc13f34a14477407ca2354356 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 22:27:18 +0800
Subject: [PATCH 3/9] fix(web): reject compact currency ranges before rendering
 math

The literal-dollar guard only caught prose whose content had whitespace
inside the delimiters, so a compact range like `costs $5/$10` still
rendered `5/` as a formula and dropped the second dollar. (markstream's
own currency check rejects `-`/`~` ranges but not `/`.)

Extend the guard to also reject a single-$ span whose content is a
numeric amount with a trailing range connector (`/`, `-`, `~`,
en/em dash) -- a complete formula never ends in a dangling operator.
Scoped to digit-led content so symbolic math is left alone, and numeric
math that is not a range (`$5/2$`, `$5-2$`, `$0.5$`) still
renders. Added tests for the range cases and the non-range math.

Addresses the follow-up Codex review comment on PR #1035.
---
 .changeset/web-katex-math.md            |  2 +-
 apps/kimi-web/src/lib/mathDelimiters.ts | 42 +++++++++++++++++++------
 apps/kimi-web/test/lib-logic.test.ts    | 26 +++++++++++++++
 3 files changed, 59 insertions(+), 11 deletions(-)

diff --git a/.changeset/web-katex-math.md b/.changeset/web-katex-math.md
index 754a9ccb2e..df65b6b2ae 100644
--- a/.changeset/web-katex-math.md
+++ b/.changeset/web-katex-math.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": patch
 ---
 
-Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX. Plain prose dollars (e.g. `$PATH`, `$5 and $10`) are kept as literal text instead of being swallowed as a formula.
+Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX. Plain prose dollars and compact price ranges (e.g. `$PATH`, `$5 and $10`, `$5/$10`) are kept as literal text instead of being swallowed as a formula.
diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
index 2fbba7cbf8..9343546043 100644
--- a/apps/kimi-web/src/lib/mathDelimiters.ts
+++ b/apps/kimi-web/src/lib/mathDelimiters.ts
@@ -1,19 +1,41 @@
 import type { MarkdownToken } from 'markstream-vue';
 
+// A numeric amount with a trailing range connector, e.g. the `5/` in
+// `$5/$10` or the `5-` in `$5-$10`. A complete formula never ends in a
+// dangling operator, so this is a compact prose range rather than math.
+// Scoped to digit-led content so symbolic math like `$\frac{a}{b}-$` is left
+// alone. The library already rejects `-`/`~` ranges, but not `/`, so we
+// cover the full set here for defense in depth.
+const TRAILING_RANGE_CONNECTOR = /^\d[\d,.]*\s*[-/~–—]\s*$/;
+
+/**
+ * True when a single-`$` inline span is almost certainly plain prose dollars,
+ * not a real LaTeX formula.
+ *
+ * Real inline math is written tight (`$E=mc^2$`, `$\frac{1}{2}$`), so:
+ *   - whitespace inside the delimiters (`PATH before `, `5 and `) means prose
+ *     like `Check $PATH before $HOME` or `costs $5 and $10`;
+ *   - a number with a trailing range connector (`5/`, `5-`) means a compact
+ *     prose range like `costs $5/$10` or `costs $5-$10`.
+ */
+function isProseDollarSpan(content: string): boolean {
+  if (/^\s|\s$/.test(content)) return true;
+  if (TRAILING_RANGE_CONNECTOR.test(content.trim())) return true;
+  return false;
+}
+
 /**
  * Guard ordinary prose dollars from being rendered as KaTeX inline math.
  *
  * markstream renders `$…$` as inline math once KaTeX is enabled, but its
- * tokenizer has no "no whitespace inside the delimiters" rule, so two
- * dollar-prefixed tokens in plain prose get swallowed as one formula —
- * `Check $PATH before $HOME` and `costs $5 and $10` both render as math
- * instead of readable text.
+ * tokenizer is lax: it has no "no whitespace inside the delimiters" rule and
+ * only rejects `-`/`~` currency ranges, so prose like
+ * `Check $PATH before $HOME`, `costs $5 and $10`, and `costs $5/$10` all get
+ * swallowed as one formula instead of readable text.
  *
- * Real inline math is written tight (`$E=mc^2$`, `$\frac{1}{2}$`), while the
- * prose false-positives always have whitespace inside the delimiters
- * (`PATH before `, `5 and `). So a single-`$` span whose content starts or
- * ends with whitespace is treated as literal `$…$` text again. Block `$$…$$`
- * math and tight inline math are left untouched.
+ * A single-`$` span that looks like prose (see isProseDollarSpan) is turned
+ * back into literal `$…$` text. Block `$$…$$` math and tight inline math are
+ * left untouched.
  *
  * This runs on the flat markdown-it token stream, so it also covers dollars
  * nested inside lists and blockquotes (their `inline` tokens sit at the top
@@ -26,7 +48,7 @@ export function guardLiteralDollarMath(tokens: MarkdownToken[]): MarkdownToken[]
       if (
         child.type === 'math_inline' &&
         child.markup === '$' &&
-        /^\s|\s$/.test(child.content ?? '')
+        isProseDollarSpan(child.content ?? '')
       ) {
         child.type = 'text';
         child.markup = '';
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index e4d8824d64..9fc4104441 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -134,4 +134,30 @@ describe('guardLiteralDollarMath', () => {
       'math_inline',
     ]);
   });
+
+  it('keeps compact prose currency ranges as text, not inline math', () => {
+    for (const text of [
+      'costs $5/$10 here',
+      'costs $5-$10 here',
+      'costs $5~$10 here',
+      'ranges from $1,000/$2,000 today',
+    ]) {
+      expect(types(text)).not.toContain('math_inline');
+      expect(render(text)).toEqual([{ type: 'text', content: text }]);
+    }
+  });
+
+  it('still renders numeric math that is not a range', () => {
+    // Division / subtraction have content after the operator, so they are real
+    // formulas, not a dangling range connector.
+    expect(render('rate $5/2$ per unit')).toEqual([
+      { type: 'text', content: 'rate ' },
+      { type: 'math_inline', content: '5/2' },
+      { type: 'text', content: ' per unit' },
+    ]);
+    expect(render('math $5-2$ done').map((n) => n.type)).toContain('math_inline');
+    for (const text of ['amount $0.5$ exactly', 'neg $-5$ value']) {
+      expect(types(text)).toContain('math_inline');
+    }
+  });
 });

From 50c92564a3113eb1e2d254eaf7dd225b54ebec46 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 23:11:36 +0800
Subject: [PATCH 4/9] fix(web): treat shell/path dollar pairs as literal text

Adjacent shell variables and PATH-like values (`Use \$HOME/bin:\$PATH`,
`\$PATH:\$HOME`) were still rendered as math, because the prose-dollar
guard only looked at the span's own content (whitespace inside the
delimiters, or a trailing numeric range connector) and never at what
touches the delimiters from the outside.

Replace the two bespoke heuristics with the two industry-standard rules,
now driven by the surrounding text tokens:

  - Pandoc (tex_math_dollars): no whitespace immediately inside the
    delimiters.
  - GitHub: each \$ must be bounded on its outer side by whitespace, a
    line boundary, or structural punctuation. A letter or digit there
    means a second prose token, so the span is literal text.

The GitHub outer-boundary rule subsumes the old numeric-range check (a
closing \$ in \$5/\$10 is followed by a digit) and also catches
shell/path cases Pandoc's inner rule misses. Normal math -- including
bare \$x\$, \$x^2\$., and (\$x^2\$) -- still renders. Added
tests for shell/path values and punctuation-wrapped math.

Addresses the third Codex review comment on PR #1035.
---
 .changeset/web-katex-math.md            |  2 +-
 apps/kimi-web/src/lib/mathDelimiters.ts | 73 ++++++++++++++++---------
 apps/kimi-web/test/lib-logic.test.ts    | 22 ++++++++
 3 files changed, 71 insertions(+), 26 deletions(-)

diff --git a/.changeset/web-katex-math.md b/.changeset/web-katex-math.md
index df65b6b2ae..01096f6eea 100644
--- a/.changeset/web-katex-math.md
+++ b/.changeset/web-katex-math.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": patch
 ---
 
-Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX. Plain prose dollars and compact price ranges (e.g. `$PATH`, `$5 and $10`, `$5/$10`) are kept as literal text instead of being swallowed as a formula.
+Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX. Plain prose dollars, compact price ranges, and shell/path values (e.g. `$PATH`, `$5/$10`, `$HOME/bin:$PATH`) are kept as literal text instead of being swallowed as a formula.
diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
index 9343546043..6a552d9c9a 100644
--- a/apps/kimi-web/src/lib/mathDelimiters.ts
+++ b/apps/kimi-web/src/lib/mathDelimiters.ts
@@ -1,26 +1,44 @@
 import type { MarkdownToken } from 'markstream-vue';
 
-// A numeric amount with a trailing range connector, e.g. the `5/` in
-// `$5/$10` or the `5-` in `$5-$10`. A complete formula never ends in a
-// dangling operator, so this is a compact prose range rather than math.
-// Scoped to digit-led content so symbolic math like `$\frac{a}{b}-$` is left
-// alone. The library already rejects `-`/`~` ranges, but not `/`, so we
-// cover the full set here for defense in depth.
-const TRAILING_RANGE_CONNECTOR = /^\d[\d,.]*\s*[-/~–—]\s*$/;
+// Characters that may sit immediately OUTSIDE a `$` delimiter while still
+// treating it as math — i.e. structural punctuation, not a prose token. A
+// letter or digit here means a second prose token (`$PATH:$HOME`, `$5/$10`).
+//   - left of an opening `$`: whitespace / line boundary / opening brackets.
+//   - right of a closing `$`: whitespace / line boundary / sentence or closing
+//     punctuation (so `$x^2$.` and `($x$)` still render).
+const LEFT_BOUNDARY = /[\s([{]/;
+const RIGHT_BOUNDARY = /[\s.,;:!?)\]}]/;
+
+function isLeftBoundary(char: string | undefined): boolean {
+  return !char || LEFT_BOUNDARY.test(char);
+}
+
+function isRightBoundary(char: string | undefined): boolean {
+  return !char || RIGHT_BOUNDARY.test(char);
+}
 
 /**
  * True when a single-`$` inline span is almost certainly plain prose dollars,
- * not a real LaTeX formula.
+ * not a real LaTeX formula. Combines the two widely-used industry rules:
  *
- * Real inline math is written tight (`$E=mc^2$`, `$\frac{1}{2}$`), so:
- *   - whitespace inside the delimiters (`PATH before `, `5 and `) means prose
- *     like `Check $PATH before $HOME` or `costs $5 and $10`;
- *   - a number with a trailing range connector (`5/`, `5-`) means a compact
- *     prose range like `costs $5/$10` or `costs $5-$10`.
+ *   - Pandoc (`tex_math_dollars`): no whitespace immediately inside the
+ *     delimiters — catches `Check $PATH before $HOME`, `costs $5 and $10`.
+ *   - GitHub: each `$` must be bounded on its outer side by whitespace, a line
+ *     boundary, or structural punctuation — catches compact prose where a
+ *     second token touches the closing `$`, such as `costs $5/$10`,
+ *     `Use $HOME/bin:$PATH`, or `$foo_$bar`.
+ *
+ * `prevChar` / `nextChar` are the characters immediately before the opening `$`
+ * and after the closing `$`, taken from the neighbouring text tokens.
  */
-function isProseDollarSpan(content: string): boolean {
+function isProseDollarSpan(
+  content: string,
+  prevChar: string | undefined,
+  nextChar: string | undefined,
+): boolean {
   if (/^\s|\s$/.test(content)) return true;
-  if (TRAILING_RANGE_CONNECTOR.test(content.trim())) return true;
+  if (!isLeftBoundary(prevChar)) return true;
+  if (!isRightBoundary(nextChar)) return true;
   return false;
 }
 
@@ -28,10 +46,10 @@ function isProseDollarSpan(content: string): boolean {
  * Guard ordinary prose dollars from being rendered as KaTeX inline math.
  *
  * markstream renders `$…$` as inline math once KaTeX is enabled, but its
- * tokenizer is lax: it has no "no whitespace inside the delimiters" rule and
- * only rejects `-`/`~` currency ranges, so prose like
- * `Check $PATH before $HOME`, `costs $5 and $10`, and `costs $5/$10` all get
- * swallowed as one formula instead of readable text.
+ * tokenizer is lax — it mechanically pairs any two `$` characters — so prose
+ * like `Check $PATH before $HOME`, `costs $5/$10`, and
+ * `Use $HOME/bin:$PATH` all get swallowed as one formula instead of readable
+ * text.
  *
  * A single-`$` span that looks like prose (see isProseDollarSpan) is turned
  * back into literal `$…$` text. Block `$$…$$` math and tight inline math are
@@ -44,12 +62,17 @@ function isProseDollarSpan(content: string): boolean {
 export function guardLiteralDollarMath(tokens: MarkdownToken[]): MarkdownToken[] {
   for (const token of tokens) {
     if (token.type !== 'inline' || !token.children) continue;
-    for (const child of token.children) {
-      if (
-        child.type === 'math_inline' &&
-        child.markup === '$' &&
-        isProseDollarSpan(child.content ?? '')
-      ) {
+    const children = token.children;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i]!;
+      if (child.type !== 'math_inline' || child.markup !== '$') continue;
+
+      const prev = children[i - 1];
+      const next = children[i + 1];
+      const prevChar = prev?.type === 'text' ? prev.content?.slice(-1) : undefined;
+      const nextChar = next?.type === 'text' ? next.content?.charAt(0) : undefined;
+
+      if (isProseDollarSpan(child.content ?? '', prevChar, nextChar)) {
         child.type = 'text';
         child.markup = '';
         child.content = `$${child.content ?? ''}$`;
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index 9fc4104441..3e756c12a2 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -160,4 +160,26 @@ describe('guardLiteralDollarMath', () => {
       expect(types(text)).toContain('math_inline');
     }
   });
+
+  it('keeps shell variables and path-like values as text', () => {
+    for (const text of [
+      'Use $HOME/bin:$PATH now',
+      'echo $PATH:$HOME here',
+      'var $foo_$bar x',
+      'obj $a.$b y',
+    ]) {
+      expect(types(text)).not.toContain('math_inline');
+      expect(render(text)).toEqual([{ type: 'text', content: text }]);
+    }
+  });
+
+  it('still renders math next to sentence punctuation or brackets', () => {
+    // Trailing period / comma and wrapping parentheses are valid boundaries.
+    expect(render('equals $x^2$. today')).toEqual([
+      { type: 'text', content: 'equals ' },
+      { type: 'math_inline', content: 'x^2' },
+      { type: 'text', content: '. today' },
+    ]);
+    expect(render('see ($x^2$) here').map((n) => n.type)).toContain('math_inline');
+  });
 });

From 06201d3da58424d4c0bbf2ef94414ff064398a72 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 23:24:11 +0800
Subject: [PATCH 5/9] fix(web): render math next to CJK punctuation and quotes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The outer-boundary guard only accepted ASCII punctuation, so a formula
followed by full-width punctuation or wrapped in typographic quotes was
misclassified as prose: `公式为 \$E=mc^2\$，其中` and `“\$x\$”`
showed raw dollars instead of rendering.

Invert the boundary check from an allow-list of ASCII punctuation to a
deny-list of ASCII letters/digits. A \$ glued to an ASCII letter/digit
still means a second prose token (\$PATH:\$HOME, \$5/\$10), but
whitespace, line boundaries, and every other character -- full-width
punctuation, CJK ideographs, curly quotes -- is now a valid math
boundary, which is the correct behavior for localized prose.

Addresses the fourth Codex review comment on PR #1035.
---
 apps/kimi-web/src/lib/mathDelimiters.ts | 39 ++++++++++++-------------
 apps/kimi-web/test/lib-logic.test.ts    | 18 ++++++++++++
 2 files changed, 36 insertions(+), 21 deletions(-)

diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
index 6a552d9c9a..f769977ff8 100644
--- a/apps/kimi-web/src/lib/mathDelimiters.ts
+++ b/apps/kimi-web/src/lib/mathDelimiters.ts
@@ -1,32 +1,29 @@
 import type { MarkdownToken } from 'markstream-vue';
 
-// Characters that may sit immediately OUTSIDE a `$` delimiter while still
-// treating it as math — i.e. structural punctuation, not a prose token. A
-// letter or digit here means a second prose token (`$PATH:$HOME`, `$5/$10`).
-//   - left of an opening `$`: whitespace / line boundary / opening brackets.
-//   - right of a closing `$`: whitespace / line boundary / sentence or closing
-//     punctuation (so `$x^2$.` and `($x$)` still render).
-const LEFT_BOUNDARY = /[\s([{]/;
-const RIGHT_BOUNDARY = /[\s.,;:!?)\]}]/;
+// An ASCII letter or digit glued to the OUTSIDE of a `$` delimiter means a
+// second prose token is attached (`$PATH:$HOME`, `$5/$10`, `$foo_$bar`), so
+// the span is literal text, not math. Everything else — whitespace, line
+// boundaries, and any non-ASCII-alphanumeric character — is a valid math
+// boundary. That deliberately includes punctuation (ASCII and full-width/CJK),
+// CJK ideographs, and curly/typographic quotes, so localized prose like
+// `公式为 $E=mc^2$，其中` and quoted formulas like `“$x$”` still render.
+const ASCII_ALNUM = /[A-Za-z0-9]/;
 
-function isLeftBoundary(char: string | undefined): boolean {
-  return !char || LEFT_BOUNDARY.test(char);
-}
-
-function isRightBoundary(char: string | undefined): boolean {
-  return !char || RIGHT_BOUNDARY.test(char);
+function touchesProseToken(char: string | undefined): boolean {
+  return char !== undefined && ASCII_ALNUM.test(char);
 }
 
 /**
  * True when a single-`$` inline span is almost certainly plain prose dollars,
- * not a real LaTeX formula. Combines the two widely-used industry rules:
+ * not a real LaTeX formula. Combines two widely-used industry rules:
  *
  *   - Pandoc (`tex_math_dollars`): no whitespace immediately inside the
  *     delimiters — catches `Check $PATH before $HOME`, `costs $5 and $10`.
- *   - GitHub: each `$` must be bounded on its outer side by whitespace, a line
- *     boundary, or structural punctuation — catches compact prose where a
- *     second token touches the closing `$`, such as `costs $5/$10`,
- *     `Use $HOME/bin:$PATH`, or `$foo_$bar`.
+ *   - GitHub-style outer boundary, generalized beyond ASCII: a `$` glued to an
+ *     ASCII letter or digit means a second prose token, so the span is literal
+ *     text. Catches compact prose like `costs $5/$10`, `Use $HOME/bin:$PATH`,
+ *     and `$foo_$bar`, while still allowing CJK punctuation and quotes around
+ *     real formulas.
  *
  * `prevChar` / `nextChar` are the characters immediately before the opening `$`
  * and after the closing `$`, taken from the neighbouring text tokens.
@@ -37,8 +34,8 @@ function isProseDollarSpan(
   nextChar: string | undefined,
 ): boolean {
   if (/^\s|\s$/.test(content)) return true;
-  if (!isLeftBoundary(prevChar)) return true;
-  if (!isRightBoundary(nextChar)) return true;
+  if (touchesProseToken(prevChar)) return true;
+  if (touchesProseToken(nextChar)) return true;
   return false;
 }
 
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index 3e756c12a2..57da828dbb 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -182,4 +182,22 @@ describe('guardLiteralDollarMath', () => {
     ]);
     expect(render('see ($x^2$) here').map((n) => n.type)).toContain('math_inline');
   });
+
+  it('renders math in CJK prose and inside typographic quotes', () => {
+    // Full-width comma / period and CJK ideographs are valid boundaries.
+    expect(render('公式为 $E=mc^2$，其中')).toEqual([
+      { type: 'text', content: '公式为 ' },
+      { type: 'math_inline', content: 'E=mc^2' },
+      { type: 'text', content: '，其中' },
+    ]);
+    expect(render('中文 $x^2$。').map((n) => n.type)).toContain('math_inline');
+    // Curly quotes wrapping a formula.
+    expect(render('“$x$”')).toEqual([
+      { type: 'text', content: '“' },
+      { type: 'math_inline', content: 'x' },
+      { type: 'text', content: '”' },
+    ]);
+    // Math jammed against CJK ideographs with no spaces still renders.
+    expect(render('公式$E=mc^2$表明').map((n) => n.type)).toContain('math_inline');
+  });
 });

From 35346a87605d8004999f7cb11730249c27972bc8 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 23:48:33 +0800
Subject: [PATCH 6/9] fix(web): preserve later math after literal-dollar spans
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A prose dollar in front of a real formula in the same inline run
(`costs $5 and formula $x$`, `Use \$HOME before $E=mc^2$`) exposed
the core limit of the token-level guard: markstream's tokenizer greedily
pairs the first literal \$ with the formula's opening \$ before any hook
runs, so converting that span back to text could only blank it -- the
later formula's opening \$ was already consumed and the formula rendered
as raw text.

Move the guard from postTransformTokens to a source-level preprocessor
that runs before tokenization. escapeProseDollars protects code spans,
fenced code blocks, and \$\$…\$\$ display math, then pairs single \$
delimiters using the Pandoc (tight delimiters) and GitHub-style
outer-boundary rules: any \$ without a valid partner is escaped as
\\\$, so the tokenizer leaves it literal while real formulas -- including
ones that come after a prose dollar -- still parse as math.

The component now preprocesses each markdown segment's text and the
postTransformTokens hook is gone. Rewrote the tests around the
string-in/string-out helper, including the prose-before-formula case,
code spans, fenced code, and block math.

Addresses the fifth Codex review comment on PR #1035.
---
 .../kimi-web/src/components/chat/Markdown.vue |  12 +-
 apps/kimi-web/src/lib/mathDelimiters.ts       | 167 ++++++++++--------
 apps/kimi-web/test/lib-logic.test.ts          | 167 +++++++-----------
 3 files changed, 160 insertions(+), 186 deletions(-)

diff --git a/apps/kimi-web/src/components/chat/Markdown.vue b/apps/kimi-web/src/components/chat/Markdown.vue
index 87e1429593..c256eadb46 100644
--- a/apps/kimi-web/src/components/chat/Markdown.vue
+++ b/apps/kimi-web/src/components/chat/Markdown.vue
@@ -3,13 +3,12 @@
 import { computed, inject, nextTick, onMounted, onUnmounted, reactive, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { MarkdownRender, enableKatex } from 'markstream-vue';
-import type { ParseOptions } from 'markstream-vue';
 import { useIsDark } from '../../composables/useIsDark';
 import type { FilePreviewRequest } from '../../types';
 import { collectFilePathAliases, findFilePathLinks } from '../../lib/filePathLinks';
 import { markdownRenderPlan } from '../../lib/markdownPerformance';
 import { copyTextToClipboard } from '../../lib/clipboard';
-import { guardLiteralDollarMath } from '../../lib/mathDelimiters';
+import { escapeProseDollars } from '../../lib/mathDelimiters';
 // px-based CSS build (our app is px, not rem). Imported here so the styles
 // load wherever Markdown is used; scoped overrides below re-skin it to
 // Terminal Pro. Importing the same file from multiple components is a no-op
@@ -23,10 +22,6 @@ import 'markstream-vue/index.px.css';
 import 'katex/dist/katex.min.css';
 enableKatex();
 
-// Keep `$…$` inline math but stop two prose dollars (`$PATH before $HOME`,
-// `$5 and $10`) from being swallowed as one formula. See mathDelimiters.ts.
-const parseOptions: ParseOptions = { postTransformTokens: guardLiteralDollarMath };
-
 const { t } = useI18n();
 
 const resolveImage = inject<(src: string) => Promise<string>>('resolveImage');
@@ -326,12 +321,12 @@ const segments = computed<Segment[]>(() => {
     // as a boundary out of the markdown segment).
     const lead = m[1] ?? '';
     const before = text.slice(lastIndex, m.index) + (lead ? lead : '');
-    if (before.trim()) out.push({ kind: 'md', text: before });
+    if (before.trim()) out.push({ kind: 'md', text: escapeProseDollars(before) });
     out.push({ kind: 'diff', code: m[2] ?? '' });
     lastIndex = DIFF_FENCE_RE.lastIndex;
   }
   const tail = text.slice(lastIndex);
-  if (tail.trim() || out.length === 0) out.push({ kind: 'md', text: tail });
+  if (tail.trim() || out.length === 0) out.push({ kind: 'md', text: escapeProseDollars(tail) });
   return out;
 });
 
@@ -366,7 +361,6 @@ function copyDiff(code: string, idx: number) {
       <MarkdownRender
         v-if="seg.kind === 'md'"
         :content="seg.text"
-        :parse-options="parseOptions"
         mode="chat"
         :code-renderer="renderPlan.codeRenderer"
         :is-dark="isDark"
diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
index f769977ff8..2ad3b3093e 100644
--- a/apps/kimi-web/src/lib/mathDelimiters.ts
+++ b/apps/kimi-web/src/lib/mathDelimiters.ts
@@ -1,81 +1,110 @@
-import type { MarkdownToken } from 'markstream-vue';
-
-// An ASCII letter or digit glued to the OUTSIDE of a `$` delimiter means a
-// second prose token is attached (`$PATH:$HOME`, `$5/$10`, `$foo_$bar`), so
-// the span is literal text, not math. Everything else — whitespace, line
-// boundaries, and any non-ASCII-alphanumeric character — is a valid math
-// boundary. That deliberately includes punctuation (ASCII and full-width/CJK),
-// CJK ideographs, and curly/typographic quotes, so localized prose like
-// `公式为 $E=mc^2$，其中` and quoted formulas like `“$x$”` still render.
-const ASCII_ALNUM = /[A-Za-z0-9]/;
-
-function touchesProseToken(char: string | undefined): boolean {
-  return char !== undefined && ASCII_ALNUM.test(char);
-}
-
 /**
- * True when a single-`$` inline span is almost certainly plain prose dollars,
- * not a real LaTeX formula. Combines two widely-used industry rules:
+ * Escape prose `$` characters so they are not mistaken for inline math.
+ *
+ * markstream renders `$…$` as inline math once KaTeX is enabled, but its
+ * tokenizer greedily pairs any two `$` characters with no notion of "this is a
+ * price / env var / path, not a formula". Worse, that greedy pairing runs
+ * *before* any token-level hook, so a prose dollar in front of a real formula
+ * (`costs $5 and formula $x$`) steals the formula's opening `$`, and fixing it
+ * after the fact can only blank the span — the later formula is lost.
  *
- *   - Pandoc (`tex_math_dollars`): no whitespace immediately inside the
- *     delimiters — catches `Check $PATH before $HOME`, `costs $5 and $10`.
- *   - GitHub-style outer boundary, generalized beyond ASCII: a `$` glued to an
- *     ASCII letter or digit means a second prose token, so the span is literal
- *     text. Catches compact prose like `costs $5/$10`, `Use $HOME/bin:$PATH`,
- *     and `$foo_$bar`, while still allowing CJK punctuation and quotes around
- *     real formulas.
+ * So we fix it at the source: a `$` is only a math delimiter when it has a
+ * valid partner under the two widely-used industry rules:
  *
- * `prevChar` / `nextChar` are the characters immediately before the opening `$`
- * and after the closing `$`, taken from the neighbouring text tokens.
+ *   - Pandoc (`tex_math_dollars`): the opening `$` must be followed by a
+ *     non-space, the closing `$` must be preceded by a non-space.
+ *   - GitHub-style outer boundary: each `$` must not be glued to an ASCII
+ *     letter or digit on its outer side (whitespace, line boundaries, and any
+ *     other character — including CJK punctuation/ideographs and curly quotes
+ *     — are valid boundaries).
+ *
+ * `$` characters that fail to form a valid pair are escaped as `\$`, which the
+ * tokenizer leaves as a literal dollar. Code spans, fenced code blocks, and
+ * `$$…$$` display math are left untouched.
  */
-function isProseDollarSpan(
-  content: string,
-  prevChar: string | undefined,
-  nextChar: string | undefined,
-): boolean {
-  if (/^\s|\s$/.test(content)) return true;
-  if (touchesProseToken(prevChar)) return true;
-  if (touchesProseToken(nextChar)) return true;
-  return false;
+const FENCED_CODE_RE = /(^[ \t]{0,3}(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]{0,3}\2[ \t]*(?=\n|$))/gm;
+const INLINE_CODE_RE = /(`+)(?=[^`])[\s\S]*?\1/g;
+const BLOCK_MATH_RE = /\$\$[\s\S]*?\$\$/g;
+const PLACEHOLDER_RE = /\u0000(\d+)\u0000/g;
+const ASCII_ALNUM = /[A-Za-z0-9]/;
+
+/** Replace protected regions (code / display math) with opaque placeholders. */
+function protect(src: string): { text: string; protected: string[] } {
+  const stash: string[] = [];
+  const save = (match: string) => {
+    stash.push(match);
+    return `\u0000${stash.length - 1}\u0000`;
+  };
+  let text = src.replace(FENCED_CODE_RE, save);
+  text = text.replace(INLINE_CODE_RE, save);
+  text = text.replace(BLOCK_MATH_RE, save);
+  return { text, protected: stash };
+}
+
+function restore(text: string, stash: string[]): string {
+  return text.replace(PLACEHOLDER_RE, (_, n) => stash[Number(n)] ?? '');
+}
+
+/** A `$` at `i` can open inline math: tight on the right, bounded on the left. */
+function isValidOpen(text: string, i: number): boolean {
+  const after = text[i + 1];
+  if (after === undefined || /\s/.test(after) || after === '$') return false;
+  const before = text[i - 1];
+  if (before !== undefined && ASCII_ALNUM.test(before)) return false;
+  return true;
 }
 
 /**
- * Guard ordinary prose dollars from being rendered as KaTeX inline math.
- *
- * markstream renders `$…$` as inline math once KaTeX is enabled, but its
- * tokenizer is lax — it mechanically pairs any two `$` characters — so prose
- * like `Check $PATH before $HOME`, `costs $5/$10`, and
- * `Use $HOME/bin:$PATH` all get swallowed as one formula instead of readable
- * text.
- *
- * A single-`$` span that looks like prose (see isProseDollarSpan) is turned
- * back into literal `$…$` text. Block `$$…$$` math and tight inline math are
- * left untouched.
- *
- * This runs on the flat markdown-it token stream, so it also covers dollars
- * nested inside lists and blockquotes (their `inline` tokens sit at the top
- * level of the stream). Code spans are already excluded by the tokenizer.
+ * The index of the `$` that closes an opener at `openIdx`, or -1 if the nearest
+ * candidate is not a valid closer (so the opener is prose). We only consider
+ * the nearest `$`: any other `$` in between would be prose that itself failed
+ * to pair, and skipping it would over-span real text.
  */
-export function guardLiteralDollarMath(tokens: MarkdownToken[]): MarkdownToken[] {
-  for (const token of tokens) {
-    if (token.type !== 'inline' || !token.children) continue;
-    const children = token.children;
-    for (let i = 0; i < children.length; i++) {
-      const child = children[i]!;
-      if (child.type !== 'math_inline' || child.markup !== '$') continue;
-
-      const prev = children[i - 1];
-      const next = children[i + 1];
-      const prevChar = prev?.type === 'text' ? prev.content?.slice(-1) : undefined;
-      const nextChar = next?.type === 'text' ? next.content?.charAt(0) : undefined;
+function findValidClose(text: string, openIdx: number): number {
+  const closeIdx = text.indexOf('$', openIdx + 1);
+  if (closeIdx === -1) return -1;
+  const before = text[closeIdx - 1];
+  if (before === undefined || /\s/.test(before)) return -1;
+  const after = text[closeIdx + 1];
+  if (after !== undefined && ASCII_ALNUM.test(after)) return -1;
+  return closeIdx;
+}
 
-      if (isProseDollarSpan(child.content ?? '', prevChar, nextChar)) {
-        child.type = 'text';
-        child.markup = '';
-        child.content = `$${child.content ?? ''}$`;
-        child.children = null;
-      }
+/** Pair valid `$…$` spans and escape every other `$` as `\$`. */
+function pairAndEscape(text: string): string {
+  let out = '';
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '\\' && text[i + 1] === '$') {
+      out += '\\$';
+      i += 2;
+      continue;
+    }
+    if (ch !== '$') {
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!isValidOpen(text, i)) {
+      out += '\\$';
+      i++;
+      continue;
     }
+    const closeIdx = findValidClose(text, i);
+    if (closeIdx === -1) {
+      out += '\\$';
+      i++;
+      continue;
+    }
+    out += text.slice(i, closeIdx + 1);
+    i = closeIdx + 1;
   }
-  return tokens;
+  return out;
+}
+
+export function escapeProseDollars(src: string): string {
+  if (!src.includes('$')) return src;
+  const { text, protected: stash } = protect(src);
+  return restore(pairAndEscape(text), stash);
 }
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index 57da828dbb..aa7bb02a64 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -1,11 +1,10 @@
-import { getMarkdown, parseMarkdownToStructure } from 'markstream-vue';
 import { describe, expect, it } from 'vitest';
 import {
   collectFilePathAliases,
   findFilePathLinks,
   parseFilePathLinkCandidate,
 } from '../src/lib/filePathLinks';
-import { guardLiteralDollarMath } from '../src/lib/mathDelimiters';
+import { escapeProseDollars } from '../src/lib/mathDelimiters';
 import { parseDiff } from '../src/lib/parseDiff';
 import { normalizeToolName, toolSummary } from '../src/lib/toolMeta';
 
@@ -79,125 +78,77 @@ describe('toolMeta', () => {
   });
 });
 
-// Flatten a parsed node tree into leaf-ish `{type, content}` entries so the
-// assertions below don't care about paragraph/blockquote/list nesting.
-type FlatNode = { type: string; content?: string };
-function flatten(nodes: unknown[]): FlatNode[] {
-  const out: FlatNode[] = [];
-  for (const raw of nodes) {
-    const n = raw as { type: string; content?: string; children?: unknown[] };
-    if (n.children?.length) out.push(...flatten(n.children));
-    else out.push({ type: n.type, content: n.content });
-  }
-  return out;
-}
-
-describe('guardLiteralDollarMath', () => {
-  const md = getMarkdown('guardLiteralDollarMath');
-  const render = (text: string) =>
-    flatten(parseMarkdownToStructure(text, md, { postTransformTokens: guardLiteralDollarMath }));
-  const types = (text: string) => render(text).map((n) => n.type);
-
-  it('keeps literal-dollar prose as text, not inline math', () => {
-    for (const text of ['Check $PATH before $HOME', 'costs $5 and $10']) {
-      expect(types(text)).not.toContain('math_inline');
-      expect(render(text)).toEqual([{ type: 'text', content: text }]);
-    }
+describe('escapeProseDollars', () => {
+  it('escapes literal-dollar prose so it is not parsed as math', () => {
+    expect(escapeProseDollars('Check $PATH before $HOME')).toBe(
+      'Check \\$PATH before \\$HOME',
+    );
+    expect(escapeProseDollars('costs $5 and $10')).toBe('costs \\$5 and \\$10');
+    expect(escapeProseDollars('it costs $5')).toBe('it costs \\$5');
   });
 
-  it('still renders tight inline math and block math', () => {
-    expect(render('Einstein $E=mc^2$ famous')).toEqual([
-      { type: 'text', content: 'Einstein ' },
-      { type: 'math_inline', content: 'E=mc^2' },
-      { type: 'text', content: ' famous' },
-    ]);
-    expect(render('inline $\\frac{1}{2}$ math').map((n) => n.type)).toContain('math_inline');
-    expect(render('$$a^2 + b^2 = c^2$$')).toEqual([
-      { type: 'math_block', content: 'a^2 + b^2 = c^2' },
-    ]);
+  it('escapes compact prose currency ranges', () => {
+    expect(escapeProseDollars('costs $5/$10 here')).toBe('costs \\$5/\\$10 here');
+    expect(escapeProseDollars('costs $5-$10 here')).toBe('costs \\$5-\\$10 here');
+    expect(escapeProseDollars('ranges from $1,000/$2,000 today')).toBe(
+      'ranges from \\$1,000/\\$2,000 today',
+    );
   });
 
-  it('guards prose dollars nested inside lists and blockquotes', () => {
-    expect(types('- $5 and $10')).not.toContain('math_inline');
-    expect(types('> $PATH before $HOME')).not.toContain('math_inline');
+  it('escapes shell variables and path-like values', () => {
+    expect(escapeProseDollars('Use $HOME/bin:$PATH now')).toBe(
+      'Use \\$HOME/bin:\\$PATH now',
+    );
+    expect(escapeProseDollars('echo $PATH:$HOME here')).toBe(
+      'echo \\$PATH:\\$HOME here',
+    );
+    expect(escapeProseDollars('var $foo_$bar x')).toBe('var \\$foo_\\$bar x');
   });
 
-  it('leaves code spans and a single unmatched dollar untouched', () => {
-    expect(types('code `$5 and $10` here')).not.toContain('math_inline');
-    expect(render('it costs $5')).toEqual([{ type: 'text', content: 'it costs $5' }]);
+  it('preserves a real formula that follows a prose dollar', () => {
+    // The prose `$` must not steal the formula's opening `$`.
+    expect(escapeProseDollars('costs $5 and formula $x$')).toBe(
+      'costs \\$5 and formula $x$',
+    );
+    expect(escapeProseDollars('Use $HOME before $E=mc^2$')).toBe(
+      'Use \\$HOME before $E=mc^2$',
+    );
+    expect(escapeProseDollars('price $5 then $x^2$ done')).toBe(
+      'price \\$5 then $x^2$ done',
+    );
+    expect(escapeProseDollars('$5 and $10 and $x$')).toBe('\\$5 and \\$10 and $x$');
   });
 
-  it('keeps multiple real inline math spans on one line', () => {
-    expect(render('$A$ and $B$').map((n) => n.type)).toEqual([
-      'math_inline',
-      'text',
-      'math_inline',
-    ]);
+  it('leaves real inline and block math untouched', () => {
+    expect(escapeProseDollars('$E=mc^2$')).toBe('$E=mc^2$');
+    expect(escapeProseDollars('Einstein $E=mc^2$ famous')).toBe(
+      'Einstein $E=mc^2$ famous',
+    );
+    expect(escapeProseDollars('inline $\\frac{1}{2}$ math')).toBe(
+      'inline $\\frac{1}{2}$ math',
+    );
+    expect(escapeProseDollars('$A$ and $B$')).toBe('$A$ and $B$');
+    expect(escapeProseDollars('rate $5/2$ per unit')).toBe('rate $5/2$ per unit');
+    expect(escapeProseDollars('$$a^2 + b^2 = c^2$$')).toBe('$$a^2 + b^2 = c^2$$');
   });
 
-  it('keeps compact prose currency ranges as text, not inline math', () => {
-    for (const text of [
-      'costs $5/$10 here',
-      'costs $5-$10 here',
-      'costs $5~$10 here',
-      'ranges from $1,000/$2,000 today',
-    ]) {
-      expect(types(text)).not.toContain('math_inline');
-      expect(render(text)).toEqual([{ type: 'text', content: text }]);
-    }
+  it('leaves math next to punctuation, brackets, and CJK untouched', () => {
+    expect(escapeProseDollars('equals $x^2$. today')).toBe('equals $x^2$. today');
+    expect(escapeProseDollars('see ($x^2$) here')).toBe('see ($x^2$) here');
+    expect(escapeProseDollars('公式为 $E=mc^2$，其中')).toBe('公式为 $E=mc^2$，其中');
+    expect(escapeProseDollars('中文 $x^2$。')).toBe('中文 $x^2$。');
+    expect(escapeProseDollars('“$x$”')).toBe('“$x$”');
+    expect(escapeProseDollars('公式$E=mc^2$表明')).toBe('公式$E=mc^2$表明');
   });
 
-  it('still renders numeric math that is not a range', () => {
-    // Division / subtraction have content after the operator, so they are real
-    // formulas, not a dangling range connector.
-    expect(render('rate $5/2$ per unit')).toEqual([
-      { type: 'text', content: 'rate ' },
-      { type: 'math_inline', content: '5/2' },
-      { type: 'text', content: ' per unit' },
-    ]);
-    expect(render('math $5-2$ done').map((n) => n.type)).toContain('math_inline');
-    for (const text of ['amount $0.5$ exactly', 'neg $-5$ value']) {
-      expect(types(text)).toContain('math_inline');
-    }
+  it('does not touch dollars inside code spans or fenced code', () => {
+    expect(escapeProseDollars('code `$5 and $10` here')).toBe('code `$5 and $10` here');
+    expect(escapeProseDollars('use `$HOME` var')).toBe('use `$HOME` var');
+    const fenced = '```\n$5 and $10\n```';
+    expect(escapeProseDollars(fenced)).toBe(fenced);
   });
 
-  it('keeps shell variables and path-like values as text', () => {
-    for (const text of [
-      'Use $HOME/bin:$PATH now',
-      'echo $PATH:$HOME here',
-      'var $foo_$bar x',
-      'obj $a.$b y',
-    ]) {
-      expect(types(text)).not.toContain('math_inline');
-      expect(render(text)).toEqual([{ type: 'text', content: text }]);
-    }
-  });
-
-  it('still renders math next to sentence punctuation or brackets', () => {
-    // Trailing period / comma and wrapping parentheses are valid boundaries.
-    expect(render('equals $x^2$. today')).toEqual([
-      { type: 'text', content: 'equals ' },
-      { type: 'math_inline', content: 'x^2' },
-      { type: 'text', content: '. today' },
-    ]);
-    expect(render('see ($x^2$) here').map((n) => n.type)).toContain('math_inline');
-  });
-
-  it('renders math in CJK prose and inside typographic quotes', () => {
-    // Full-width comma / period and CJK ideographs are valid boundaries.
-    expect(render('公式为 $E=mc^2$，其中')).toEqual([
-      { type: 'text', content: '公式为 ' },
-      { type: 'math_inline', content: 'E=mc^2' },
-      { type: 'text', content: '，其中' },
-    ]);
-    expect(render('中文 $x^2$。').map((n) => n.type)).toContain('math_inline');
-    // Curly quotes wrapping a formula.
-    expect(render('“$x$”')).toEqual([
-      { type: 'text', content: '“' },
-      { type: 'math_inline', content: 'x' },
-      { type: 'text', content: '”' },
-    ]);
-    // Math jammed against CJK ideographs with no spaces still renders.
-    expect(render('公式$E=mc^2$表明').map((n) => n.type)).toContain('math_inline');
+  it('does not double-escape already-escaped dollars', () => {
+    expect(escapeProseDollars('literal \\$5 here')).toBe('literal \\$5 here');
   });
 });

From 1b4a575561a83e75d21b90a37f111909319a56fd Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Wed, 24 Jun 2026 11:36:56 +0800
Subject: [PATCH 7/9] fix(web): protect indented code blocks before escaping
 dollars

The dollar-escaping preprocessor stashed fenced code blocks, inline code,
and display math, but not 4-space / tab indented code blocks. So a
snippet like `    echo \$HOME` had its dollar rewritten to `\\$HOME`,
and because Markdown renders backslashes literally inside code, the web
chat corrupted the code to show a stray backslash.

Add an indented-code regex and protect those lines too. Also make the
placeholder restore iterative, so nested protected regions (e.g. inline
code that looks like display math) restore correctly instead of leaving
a placeholder behind.

Addresses the sixth Codex review comment on PR #1035.
---
 apps/kimi-web/src/lib/mathDelimiters.ts | 15 ++++++++++++++-
 apps/kimi-web/test/lib-logic.test.ts    |  9 +++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
index 2ad3b3093e..c906802f21 100644
--- a/apps/kimi-web/src/lib/mathDelimiters.ts
+++ b/apps/kimi-web/src/lib/mathDelimiters.ts
@@ -25,6 +25,10 @@
 const FENCED_CODE_RE = /(^[ \t]{0,3}(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]{0,3}\2[ \t]*(?=\n|$))/gm;
 const INLINE_CODE_RE = /(`+)(?=[^`])[\s\S]*?\1/g;
 const BLOCK_MATH_RE = /\$\$[\s\S]*?\$\$/g;
+// A 4-space / tab indented line is a Markdown indented code block; protect
+// each such line so its dollars are not rewritten (code renders backslashes
+// literally, so `\$HOME` would show instead of `$HOME`).
+const INDENTED_CODE_RE = /^(?: {4}|\t)[^\n]*/gm;
 const PLACEHOLDER_RE = /\u0000(\d+)\u0000/g;
 const ASCII_ALNUM = /[A-Za-z0-9]/;
 
@@ -36,13 +40,22 @@ function protect(src: string): { text: string; protected: string[] } {
     return `\u0000${stash.length - 1}\u0000`;
   };
   let text = src.replace(FENCED_CODE_RE, save);
+  text = text.replace(INDENTED_CODE_RE, save);
   text = text.replace(INLINE_CODE_RE, save);
   text = text.replace(BLOCK_MATH_RE, save);
   return { text, protected: stash };
 }
 
 function restore(text: string, stash: string[]): string {
-  return text.replace(PLACEHOLDER_RE, (_, n) => stash[Number(n)] ?? '');
+  // Protected regions can nest (e.g. inline code that looks like display math,
+  // or an indented line containing a code span), so a single pass may leave
+  // placeholders inside a just-restored region. Repeat until stable.
+  let prev = '';
+  while (prev !== text) {
+    prev = text;
+    text = text.replace(PLACEHOLDER_RE, (_, n) => stash[Number(n)] ?? '');
+  }
+  return text;
 }
 
 /** A `$` at `i` can open inline math: tight on the right, bounded on the left. */
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index aa7bb02a64..aa8a850917 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -148,6 +148,15 @@ describe('escapeProseDollars', () => {
     expect(escapeProseDollars(fenced)).toBe(fenced);
   });
 
+  it('does not touch dollars inside indented code blocks', () => {
+    // A 4-space indented line is a code block; the dollar must stay literal.
+    expect(escapeProseDollars('    echo $HOME')).toBe('    echo $HOME');
+    const block = 'before\n\n    echo $HOME\n    echo $PATH\n\nafter';
+    expect(escapeProseDollars(block)).toBe(block);
+    // Tab-indented code is protected too.
+    expect(escapeProseDollars('\techo $HOME')).toBe('\techo $HOME');
+  });
+
   it('does not double-escape already-escaped dollars', () => {
     expect(escapeProseDollars('literal \\$5 here')).toBe('literal \\$5 here');
   });

From 8343b59920e1ce380407e4757009993c860b659f Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Wed, 24 Jun 2026 11:51:43 +0800
Subject: [PATCH 8/9] fix(web): do not treat list-continuation lines as
 indented code

The indented-code regex protected every 4-space line, but inside a list
item a 4-space indent is a normal continuation paragraph, not a code
block (code under a list marker needs deeper indentation). So a message
like `- total\n    costs \$5 and \$10` had that nested line
stashed as "code", leaving its dollars un-escaped -- and the KaTeX
parser then rendered the price range as math.

Narrow the indented-code rule to a run of 4-space / tab lines that is
preceded by a blank line (or the start of the text). That still protects
real top-level indented code blocks and deeper-indented code inside
lists, while letting 4-space list-continuation lines get their dollars
escaped.

Addresses the seventh Codex review comment on PR #1035.
---
 apps/kimi-web/src/lib/mathDelimiters.ts | 13 +++++++++----
 apps/kimi-web/test/lib-logic.test.ts    |  8 ++++++++
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
index c906802f21..1db4008d68 100644
--- a/apps/kimi-web/src/lib/mathDelimiters.ts
+++ b/apps/kimi-web/src/lib/mathDelimiters.ts
@@ -25,10 +25,15 @@
 const FENCED_CODE_RE = /(^[ \t]{0,3}(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]{0,3}\2[ \t]*(?=\n|$))/gm;
 const INLINE_CODE_RE = /(`+)(?=[^`])[\s\S]*?\1/g;
 const BLOCK_MATH_RE = /\$\$[\s\S]*?\$\$/g;
-// A 4-space / tab indented line is a Markdown indented code block; protect
-// each such line so its dollars are not rewritten (code renders backslashes
-// literally, so `\$HOME` would show instead of `$HOME`).
-const INDENTED_CODE_RE = /^(?: {4}|\t)[^\n]*/gm;
+// An indented code block is a run of 4-space / tab indented lines that
+// follows a blank line (or the start of the text). The blank-line guard is
+// what separates it from a 4-space list-continuation line (e.g.
+// `- total\n    costs $5 and $10`), which Markdown treats as normal prose,
+// not code — so those must NOT be protected and their dollars still get
+// escaped. Code inside a list needs deeper indentation, which this matches
+// too once a blank line precedes it.
+const INDENTED_CODE_RE =
+  /(?:^|\n[ \t]*\n)((?: {4}|\t)[^\n]*(?:\n(?:[ \t]*\n)*(?: {4}|\t)[^\n]*)*)/g;
 const PLACEHOLDER_RE = /\u0000(\d+)\u0000/g;
 const ASCII_ALNUM = /[A-Za-z0-9]/;
 
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index aa8a850917..76c2805095 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -157,6 +157,14 @@ describe('escapeProseDollars', () => {
     expect(escapeProseDollars('\techo $HOME')).toBe('\techo $HOME');
   });
 
+  it('does not treat a 4-space list continuation as an indented code block', () => {
+    // Inside a list item a 4-space indent is continuation prose (code under a
+    // list marker needs deeper indentation), so the price range is escaped.
+    expect(escapeProseDollars('- total\n    costs $5 and $10')).toBe(
+      '- total\n    costs \\$5 and \\$10',
+    );
+  });
+
   it('does not double-escape already-escaped dollars', () => {
     expect(escapeProseDollars('literal \\$5 here')).toBe('literal \\$5 here');
   });

From 961c172706e60e6d558739e68b56e7eaf38211a5 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Wed, 24 Jun 2026 15:53:01 +0800
Subject: [PATCH 9/9] =?UTF-8?q?refactor(web):=20render=20only=20$$?=
 =?UTF-8?q?=E2=80=A6$$=20display=20math,=20drop=20single-$=20inline?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Enable KaTeX for display math only: disable markstream's inline math rule
(`md.inline.ruler.disable('math')`) via customMarkdownIt, leaving the
`math_block` rule for $$…$$. Single $ now stays literal everywhere, so
prices, env vars, shell paths, and code are never mis-rendered as math --
with no escaping, no code detection, and no preprocessor.

This removes the escapeProseDollars normalization layer and all of its
code-protection machinery (the 8 review comments it attracted were
symptoms of trying to make a lax single-$ tokenizer behave). Display
$$…$$ math continues to render via KaTeX.

Changeset updated to describe display-math-only support.
---
 .changeset/web-katex-math.md                  |   2 +-
 .../kimi-web/src/components/chat/Markdown.vue |  27 ++--
 apps/kimi-web/src/lib/mathDelimiters.ts       | 128 ------------------
 apps/kimi-web/test/lib-logic.test.ts          |  92 -------------
 4 files changed, 20 insertions(+), 229 deletions(-)
 delete mode 100644 apps/kimi-web/src/lib/mathDelimiters.ts

diff --git a/.changeset/web-katex-math.md b/.changeset/web-katex-math.md
index 01096f6eea..b09dfe6762 100644
--- a/.changeset/web-katex-math.md
+++ b/.changeset/web-katex-math.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": patch
 ---
 
-Render LaTeX math in the web chat: inline `$…$` and block `$$…$$` now display as formatted formulas via KaTeX. Plain prose dollars, compact price ranges, and shell/path values (e.g. `$PATH`, `$5/$10`, `$HOME/bin:$PATH`) are kept as literal text instead of being swallowed as a formula.
+Render LaTeX display math (`$$…$$`) in the web chat via KaTeX. Single `$` is intentionally left as literal text, so prices, env vars, and shell paths (e.g. `$PATH`, `$5/$10`, `$HOME/bin`) are never swallowed as a formula.
diff --git a/apps/kimi-web/src/components/chat/Markdown.vue b/apps/kimi-web/src/components/chat/Markdown.vue
index c256eadb46..dcafb47906 100644
--- a/apps/kimi-web/src/components/chat/Markdown.vue
+++ b/apps/kimi-web/src/components/chat/Markdown.vue
@@ -3,25 +3,35 @@
 import { computed, inject, nextTick, onMounted, onUnmounted, reactive, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { MarkdownRender, enableKatex } from 'markstream-vue';
+import type { MarkdownIt } from 'markstream-vue';
 import { useIsDark } from '../../composables/useIsDark';
 import type { FilePreviewRequest } from '../../types';
 import { collectFilePathAliases, findFilePathLinks } from '../../lib/filePathLinks';
 import { markdownRenderPlan } from '../../lib/markdownPerformance';
 import { copyTextToClipboard } from '../../lib/clipboard';
-import { escapeProseDollars } from '../../lib/mathDelimiters';
 // px-based CSS build (our app is px, not rem). Imported here so the styles
 // load wherever Markdown is used; scoped overrides below re-skin it to
 // Terminal Pro. Importing the same file from multiple components is a no-op
 // after the first (Vite dedups the CSS import).
 import 'markstream-vue/index.px.css';
-// KaTeX math: markstream renders `$…$` / `$$…$$` only after the optional katex
-// peer is enabled, and its stylesheet (+ bundled fonts) is what gives formulas
-// their layout. enableKatex() registers the default `import('katex')` loader; it
-// runs once on first import of this module and is safe at module scope. Without
-// the CSS the math renders unstyled, so both must travel together.
+// KaTeX math: markstream renders `$$…$$` display math only after the optional
+// katex peer is enabled, and its stylesheet (+ bundled fonts) is what gives
+// formulas their layout. enableKatex() registers the default `import('katex')`
+// loader; it runs once on first import of this module and is safe at module
+// scope. Without the CSS the math renders unstyled, so both must travel
+// together.
 import 'katex/dist/katex.min.css';
 enableKatex();
 
+// Only `$$…$$` display math is rendered; single `$` inline math is disabled so
+// prices, env vars, and shell paths (`$5`, `$PATH`, `$HOME/bin`) stay literal
+// without any escaping or code-detection gymnastics. `math_block` (the $$ rule)
+// is left enabled.
+function disableInlineMath(md: MarkdownIt): MarkdownIt {
+  md.inline.ruler.disable('math');
+  return md;
+}
+
 const { t } = useI18n();
 
 const resolveImage = inject<(src: string) => Promise<string>>('resolveImage');
@@ -321,12 +331,12 @@ const segments = computed<Segment[]>(() => {
     // as a boundary out of the markdown segment).
     const lead = m[1] ?? '';
     const before = text.slice(lastIndex, m.index) + (lead ? lead : '');
-    if (before.trim()) out.push({ kind: 'md', text: escapeProseDollars(before) });
+    if (before.trim()) out.push({ kind: 'md', text: before });
     out.push({ kind: 'diff', code: m[2] ?? '' });
     lastIndex = DIFF_FENCE_RE.lastIndex;
   }
   const tail = text.slice(lastIndex);
-  if (tail.trim() || out.length === 0) out.push({ kind: 'md', text: escapeProseDollars(tail) });
+  if (tail.trim() || out.length === 0) out.push({ kind: 'md', text: tail });
   return out;
 });
 
@@ -361,6 +371,7 @@ function copyDiff(code: string, idx: number) {
       <MarkdownRender
         v-if="seg.kind === 'md'"
         :content="seg.text"
+        :custom-markdown-it="disableInlineMath"
         mode="chat"
         :code-renderer="renderPlan.codeRenderer"
         :is-dark="isDark"
diff --git a/apps/kimi-web/src/lib/mathDelimiters.ts b/apps/kimi-web/src/lib/mathDelimiters.ts
deleted file mode 100644
index 1db4008d68..0000000000
--- a/apps/kimi-web/src/lib/mathDelimiters.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-/**
- * Escape prose `$` characters so they are not mistaken for inline math.
- *
- * markstream renders `$…$` as inline math once KaTeX is enabled, but its
- * tokenizer greedily pairs any two `$` characters with no notion of "this is a
- * price / env var / path, not a formula". Worse, that greedy pairing runs
- * *before* any token-level hook, so a prose dollar in front of a real formula
- * (`costs $5 and formula $x$`) steals the formula's opening `$`, and fixing it
- * after the fact can only blank the span — the later formula is lost.
- *
- * So we fix it at the source: a `$` is only a math delimiter when it has a
- * valid partner under the two widely-used industry rules:
- *
- *   - Pandoc (`tex_math_dollars`): the opening `$` must be followed by a
- *     non-space, the closing `$` must be preceded by a non-space.
- *   - GitHub-style outer boundary: each `$` must not be glued to an ASCII
- *     letter or digit on its outer side (whitespace, line boundaries, and any
- *     other character — including CJK punctuation/ideographs and curly quotes
- *     — are valid boundaries).
- *
- * `$` characters that fail to form a valid pair are escaped as `\$`, which the
- * tokenizer leaves as a literal dollar. Code spans, fenced code blocks, and
- * `$$…$$` display math are left untouched.
- */
-const FENCED_CODE_RE = /(^[ \t]{0,3}(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]{0,3}\2[ \t]*(?=\n|$))/gm;
-const INLINE_CODE_RE = /(`+)(?=[^`])[\s\S]*?\1/g;
-const BLOCK_MATH_RE = /\$\$[\s\S]*?\$\$/g;
-// An indented code block is a run of 4-space / tab indented lines that
-// follows a blank line (or the start of the text). The blank-line guard is
-// what separates it from a 4-space list-continuation line (e.g.
-// `- total\n    costs $5 and $10`), which Markdown treats as normal prose,
-// not code — so those must NOT be protected and their dollars still get
-// escaped. Code inside a list needs deeper indentation, which this matches
-// too once a blank line precedes it.
-const INDENTED_CODE_RE =
-  /(?:^|\n[ \t]*\n)((?: {4}|\t)[^\n]*(?:\n(?:[ \t]*\n)*(?: {4}|\t)[^\n]*)*)/g;
-const PLACEHOLDER_RE = /\u0000(\d+)\u0000/g;
-const ASCII_ALNUM = /[A-Za-z0-9]/;
-
-/** Replace protected regions (code / display math) with opaque placeholders. */
-function protect(src: string): { text: string; protected: string[] } {
-  const stash: string[] = [];
-  const save = (match: string) => {
-    stash.push(match);
-    return `\u0000${stash.length - 1}\u0000`;
-  };
-  let text = src.replace(FENCED_CODE_RE, save);
-  text = text.replace(INDENTED_CODE_RE, save);
-  text = text.replace(INLINE_CODE_RE, save);
-  text = text.replace(BLOCK_MATH_RE, save);
-  return { text, protected: stash };
-}
-
-function restore(text: string, stash: string[]): string {
-  // Protected regions can nest (e.g. inline code that looks like display math,
-  // or an indented line containing a code span), so a single pass may leave
-  // placeholders inside a just-restored region. Repeat until stable.
-  let prev = '';
-  while (prev !== text) {
-    prev = text;
-    text = text.replace(PLACEHOLDER_RE, (_, n) => stash[Number(n)] ?? '');
-  }
-  return text;
-}
-
-/** A `$` at `i` can open inline math: tight on the right, bounded on the left. */
-function isValidOpen(text: string, i: number): boolean {
-  const after = text[i + 1];
-  if (after === undefined || /\s/.test(after) || after === '$') return false;
-  const before = text[i - 1];
-  if (before !== undefined && ASCII_ALNUM.test(before)) return false;
-  return true;
-}
-
-/**
- * The index of the `$` that closes an opener at `openIdx`, or -1 if the nearest
- * candidate is not a valid closer (so the opener is prose). We only consider
- * the nearest `$`: any other `$` in between would be prose that itself failed
- * to pair, and skipping it would over-span real text.
- */
-function findValidClose(text: string, openIdx: number): number {
-  const closeIdx = text.indexOf('$', openIdx + 1);
-  if (closeIdx === -1) return -1;
-  const before = text[closeIdx - 1];
-  if (before === undefined || /\s/.test(before)) return -1;
-  const after = text[closeIdx + 1];
-  if (after !== undefined && ASCII_ALNUM.test(after)) return -1;
-  return closeIdx;
-}
-
-/** Pair valid `$…$` spans and escape every other `$` as `\$`. */
-function pairAndEscape(text: string): string {
-  let out = '';
-  let i = 0;
-  while (i < text.length) {
-    const ch = text[i];
-    if (ch === '\\' && text[i + 1] === '$') {
-      out += '\\$';
-      i += 2;
-      continue;
-    }
-    if (ch !== '$') {
-      out += ch;
-      i++;
-      continue;
-    }
-    if (!isValidOpen(text, i)) {
-      out += '\\$';
-      i++;
-      continue;
-    }
-    const closeIdx = findValidClose(text, i);
-    if (closeIdx === -1) {
-      out += '\\$';
-      i++;
-      continue;
-    }
-    out += text.slice(i, closeIdx + 1);
-    i = closeIdx + 1;
-  }
-  return out;
-}
-
-export function escapeProseDollars(src: string): string {
-  if (!src.includes('$')) return src;
-  const { text, protected: stash } = protect(src);
-  return restore(pairAndEscape(text), stash);
-}
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index 76c2805095..7cdd1730a9 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -4,7 +4,6 @@ import {
   findFilePathLinks,
   parseFilePathLinkCandidate,
 } from '../src/lib/filePathLinks';
-import { escapeProseDollars } from '../src/lib/mathDelimiters';
 import { parseDiff } from '../src/lib/parseDiff';
 import { normalizeToolName, toolSummary } from '../src/lib/toolMeta';
 
@@ -78,94 +77,3 @@ describe('toolMeta', () => {
   });
 });
 
-describe('escapeProseDollars', () => {
-  it('escapes literal-dollar prose so it is not parsed as math', () => {
-    expect(escapeProseDollars('Check $PATH before $HOME')).toBe(
-      'Check \\$PATH before \\$HOME',
-    );
-    expect(escapeProseDollars('costs $5 and $10')).toBe('costs \\$5 and \\$10');
-    expect(escapeProseDollars('it costs $5')).toBe('it costs \\$5');
-  });
-
-  it('escapes compact prose currency ranges', () => {
-    expect(escapeProseDollars('costs $5/$10 here')).toBe('costs \\$5/\\$10 here');
-    expect(escapeProseDollars('costs $5-$10 here')).toBe('costs \\$5-\\$10 here');
-    expect(escapeProseDollars('ranges from $1,000/$2,000 today')).toBe(
-      'ranges from \\$1,000/\\$2,000 today',
-    );
-  });
-
-  it('escapes shell variables and path-like values', () => {
-    expect(escapeProseDollars('Use $HOME/bin:$PATH now')).toBe(
-      'Use \\$HOME/bin:\\$PATH now',
-    );
-    expect(escapeProseDollars('echo $PATH:$HOME here')).toBe(
-      'echo \\$PATH:\\$HOME here',
-    );
-    expect(escapeProseDollars('var $foo_$bar x')).toBe('var \\$foo_\\$bar x');
-  });
-
-  it('preserves a real formula that follows a prose dollar', () => {
-    // The prose `$` must not steal the formula's opening `$`.
-    expect(escapeProseDollars('costs $5 and formula $x$')).toBe(
-      'costs \\$5 and formula $x$',
-    );
-    expect(escapeProseDollars('Use $HOME before $E=mc^2$')).toBe(
-      'Use \\$HOME before $E=mc^2$',
-    );
-    expect(escapeProseDollars('price $5 then $x^2$ done')).toBe(
-      'price \\$5 then $x^2$ done',
-    );
-    expect(escapeProseDollars('$5 and $10 and $x$')).toBe('\\$5 and \\$10 and $x$');
-  });
-
-  it('leaves real inline and block math untouched', () => {
-    expect(escapeProseDollars('$E=mc^2$')).toBe('$E=mc^2$');
-    expect(escapeProseDollars('Einstein $E=mc^2$ famous')).toBe(
-      'Einstein $E=mc^2$ famous',
-    );
-    expect(escapeProseDollars('inline $\\frac{1}{2}$ math')).toBe(
-      'inline $\\frac{1}{2}$ math',
-    );
-    expect(escapeProseDollars('$A$ and $B$')).toBe('$A$ and $B$');
-    expect(escapeProseDollars('rate $5/2$ per unit')).toBe('rate $5/2$ per unit');
-    expect(escapeProseDollars('$$a^2 + b^2 = c^2$$')).toBe('$$a^2 + b^2 = c^2$$');
-  });
-
-  it('leaves math next to punctuation, brackets, and CJK untouched', () => {
-    expect(escapeProseDollars('equals $x^2$. today')).toBe('equals $x^2$. today');
-    expect(escapeProseDollars('see ($x^2$) here')).toBe('see ($x^2$) here');
-    expect(escapeProseDollars('公式为 $E=mc^2$，其中')).toBe('公式为 $E=mc^2$，其中');
-    expect(escapeProseDollars('中文 $x^2$。')).toBe('中文 $x^2$。');
-    expect(escapeProseDollars('“$x$”')).toBe('“$x$”');
-    expect(escapeProseDollars('公式$E=mc^2$表明')).toBe('公式$E=mc^2$表明');
-  });
-
-  it('does not touch dollars inside code spans or fenced code', () => {
-    expect(escapeProseDollars('code `$5 and $10` here')).toBe('code `$5 and $10` here');
-    expect(escapeProseDollars('use `$HOME` var')).toBe('use `$HOME` var');
-    const fenced = '```\n$5 and $10\n```';
-    expect(escapeProseDollars(fenced)).toBe(fenced);
-  });
-
-  it('does not touch dollars inside indented code blocks', () => {
-    // A 4-space indented line is a code block; the dollar must stay literal.
-    expect(escapeProseDollars('    echo $HOME')).toBe('    echo $HOME');
-    const block = 'before\n\n    echo $HOME\n    echo $PATH\n\nafter';
-    expect(escapeProseDollars(block)).toBe(block);
-    // Tab-indented code is protected too.
-    expect(escapeProseDollars('\techo $HOME')).toBe('\techo $HOME');
-  });
-
-  it('does not treat a 4-space list continuation as an indented code block', () => {
-    // Inside a list item a 4-space indent is continuation prose (code under a
-    // list marker needs deeper indentation), so the price range is escaped.
-    expect(escapeProseDollars('- total\n    costs $5 and $10')).toBe(
-      '- total\n    costs \\$5 and \\$10',
-    );
-  });
-
-  it('does not double-escape already-escaped dollars', () => {
-    expect(escapeProseDollars('literal \\$5 here')).toBe('literal \\$5 here');
-  });
-});