diff --git a/.github/workflows/cjk-typography-ci.yml b/.github/workflows/cjk-typography-ci.yml
new file mode 100644
index 000000000..e4c9fd67b
--- /dev/null
+++ b/.github/workflows/cjk-typography-ci.yml
@@ -0,0 +1,44 @@
+name: CJK Typography CI
+
+on:
+  pull_request:
+    paths:
+      - "frontend/src/lib/cjkTypography.ts"
+      - "frontend/src/lib/tiptapCjkTypography.ts"
+      - "frontend/src/lib/markdownCommands.ts"
+      - "frontend/src/lib/__tests__/cjkTypography.test.ts"
+      - "frontend/src/components/CjkTypographyMenuActions.tsx"
+      - "frontend/src/components/MarkdownEditorImpl.tsx"
+      - "frontend/src/components/TiptapEditor.tsx"
+      - "frontend/src/components/TiptapEditorRuntime.tsx"
+      - "frontend/src/components/EditorPane.tsx"
+      - "frontend/src/components/editors/types.ts"
+      - "frontend/src/i18n/coverageTranslations.ts"
+      - ".github/workflows/cjk-typography-ci.yml"
+  push:
+    branches: ["release/v1.5.2"]
+    paths:
+      - "frontend/src/lib/cjkTypography.ts"
+      - "frontend/src/lib/tiptapCjkTypography.ts"
+      - "frontend/src/lib/__tests__/cjkTypography.test.ts"
+
+jobs:
+  cjk-typography:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: frontend
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: npm
+          cache-dependency-path: frontend/package-lock.json
+      - run: npm ci
+      - name: Guarded transform, selection, and undo regressions
+        run: npm run test:run -- src/lib/__tests__/cjkTypography.test.ts
+      - name: Lint CJK typography modules
+        run: npx eslint src/lib/cjkTypography.ts src/lib/tiptapCjkTypography.ts src/components/CjkTypographyMenuActions.tsx
+      - name: Frontend TypeScript check
+        run: npx tsc -b
diff --git a/frontend/src/components/CjkTypographyMenuActions.tsx b/frontend/src/components/CjkTypographyMenuActions.tsx
new file mode 100644
index 000000000..6591be458
--- /dev/null
+++ b/frontend/src/components/CjkTypographyMenuActions.tsx
@@ -0,0 +1,40 @@
+import { Languages, Quote, TextCursorInput } from "lucide-react";
+import { useTranslation } from "react-i18next";
+import type { CjkTypographyAction } from "@/lib/cjkTypography";
+
+const actions: Array<{ action: CjkTypographyAction; icon: typeof Languages }> = [
+  { action: "spacing", icon: TextCursorInput },
+  { action: "punctuation", icon: Languages },
+  { action: "cornerQuotes", icon: Quote },
+];
+
+/** Explicit one-click tools; no automatic input transformation or settings toggle. */
+export default function CjkTypographyMenuActions({
+  onAction, disabled = false, mobile = false,
+}: {
+  onAction: (action: CjkTypographyAction) => void;
+  disabled?: boolean;
+  mobile?: boolean;
+}) {
+  const { t } = useTranslation();
+  return (
+    <div data-cjk-typography-actions className="py-1">
+      <div className="px-3 py-1 text-[11px] font-medium text-tx-tertiary">
+        {t("cjkTypography.title")}
+      </div>
+      {actions.map(({ action, icon: Icon }) => (
+        <button key={action} type="button"
+          disabled={disabled}
+          onClick={() => onAction(action)}
+          className={"w-full flex items-center gap-2.5 px-3 py-2 text-left text-sm text-tx-secondary " +
+            (mobile ? "active:bg-app-hover " : "hover:bg-app-hover ") +
+            "transition-colors disabled:opacity-40"}>
+          <Icon size={15} className="shrink-0 text-tx-tertiary" />
+          <span>{action === "spacing" ? t("cjkTypography.spacing")
+            : action === "punctuation" ? t("cjkTypography.punctuation")
+            : t("cjkTypography.cornerQuotes")}</span>
+        </button>
+      ))}
+    </div>
+  );
+}
diff --git a/frontend/src/components/EditorPane.tsx b/frontend/src/components/EditorPane.tsx
index 7fbdcd735..c2a5c13a8 100644
--- a/frontend/src/components/EditorPane.tsx
+++ b/frontend/src/components/EditorPane.tsx
@@ -109,6 +109,8 @@ import {
   type NoteFormatConversionRequest,
 } from "@/lib/noteFormatConversion";
 import NoteThemeMenuSelect from "@/components/NoteThemeMenuSelect";
+import CjkTypographyMenuActions from "@/components/CjkTypographyMenuActions";
+import type { CjkTypographyAction } from "@/lib/cjkTypography";
 import NoteColorMarkPicker from "@/components/NoteColorMarkPicker";
 import type { NoteColorMark } from "@/types";
 import MindMapEmbedInsertDialog from "@/components/MindMapEmbedInsertDialog";
@@ -1593,6 +1595,16 @@ function OrdinaryEditorPane({
     };
   }, [showDesktopMoreMenu]);
 
+  const applyCjkTypography = (action: CjkTypographyAction) => {
+    setShowMobileMenu(false);
+    setShowDesktopMoreMenu(false);
+    // The underlying editor checks read-only again, guarding stale menu state.
+    if (!activeNote || !canEditActiveNote || effectiveLocked || isTrashed ||
+        modeSwitching || noteIsFullHtmlDoc) return;
+    const applied = editorHandleRef.current?.applyCjkTypography?.(action) === true;
+    if (!applied) toast.info(t("cjkTypography.noChanges"));
+  };
+
   const handleUpdate = useCallback(async (data: NoteEditorUpdatePayload) => {
     const currentNote = activeNoteRef.current;
     if (!currentNote || currentNote.isLocked || viewLockedIdsRef.current.has(currentNote.id)) return;
@@ -2857,6 +2869,11 @@ const moveToTrash = useCallback(async () => {
                     <span>{t('editor.showOutline')}</span>
                   </button>
                   <NoteThemeMenuSelect noteId={activeNote.id} disabled={!canWriteNote(activeNote)} />
+                  <CjkTypographyMenuActions
+                    mobile
+                    disabled={!canEditActiveNote || effectiveLocked || isTrashed || modeSwitching || noteIsFullHtmlDoc}
+                    onAction={applyCjkTypography}
+                  />
                   <div className="h-px bg-app-border mx-2 my-0.5" />
                   {/* AI ���ɱ��� */}
                   <button
@@ -3463,6 +3480,10 @@ const moveToTrash = useCallback(async () => {
                     <span>{t('editor.attachments')}</span>
                   </button>
                   <NoteThemeMenuSelect noteId={activeNote.id} disabled={!canWriteNote(activeNote)} />
+                  <CjkTypographyMenuActions
+                    disabled={!canEditActiveNote || effectiveLocked || isTrashed || modeSwitching || noteIsFullHtmlDoc}
+                    onAction={applyCjkTypography}
+                  />
                   {canSplitDocument && onSplitDocument && (
                     <button
                       onClick={() => { onSplitDocument(); setShowDesktopMoreMenu(false); }}
diff --git a/frontend/src/components/MarkdownEditorImpl.tsx b/frontend/src/components/MarkdownEditorImpl.tsx
index aed208136..0d6e1746f 100644
--- a/frontend/src/components/MarkdownEditorImpl.tsx
+++ b/frontend/src/components/MarkdownEditorImpl.tsx
@@ -176,6 +176,7 @@ import {
   insertLink,
   insertImage,
   replaceSelection,
+  applyMarkdownCjkTypography,
 } from "@/lib/markdownCommands";
 import {
   MarkdownSlashMenu,
@@ -1308,6 +1309,11 @@ export default forwardRef<NoteEditorHandle, MarkdownEditorProps>(function Markdo
         };
       },
       isReady: () => !!viewRef.current,
+      applyCjkTypography: (action) => {
+        const view = viewRef.current;
+        if (!view || !editable || !view.state.facet(EditorView.editable)) return false;
+        return applyMarkdownCjkTypography(view, action);
+      },
       insertMarkdownAtCursor: (md: string) => {
         const view = viewRef.current;
         if (!view) return false;
diff --git a/frontend/src/components/TiptapEditor.tsx b/frontend/src/components/TiptapEditor.tsx
index a0e6bb2a0..527e54845 100644
--- a/frontend/src/components/TiptapEditor.tsx
+++ b/frontend/src/components/TiptapEditor.tsx
@@ -1,5 +1,6 @@
 import { emojis } from "@tiptap/extension-emoji";
 import { getRichTextExtensions } from "@/lib/richTextExtensions";
+import { applyTiptapCjkTypography } from "@/lib/tiptapCjkTypography";
 import { EmojiSuggestionList } from "./EmojiSuggestionList";
 import RichTextBlockControls from "./RichTextBlockControls";
 import { getSlashEditorId } from "./extensions/SlashCommandExtension";
@@ -3433,6 +3434,10 @@ const TiptapEditor = forwardRef<NoteEditorHandle, TiptapEditorProps>(function Ti
         pendingSaveAckRef.current = ack;
       },
       isReady: () => !!editor && !editor.isDestroyed,
+      applyCjkTypography: (action) => {
+        if (!editor || editor.isDestroyed || !editor.isEditable) return false;
+        return applyTiptapCjkTypography(editor, action);
+      },
       insertMarkdownAtCursor: (md: string) => {
         if (!editor || editor.isDestroyed) return false;
         try {
diff --git a/frontend/src/components/TiptapEditorRuntime.tsx b/frontend/src/components/TiptapEditorRuntime.tsx
index 286a3640a..a28ad3f74 100644
--- a/frontend/src/components/TiptapEditorRuntime.tsx
+++ b/frontend/src/components/TiptapEditorRuntime.tsx
@@ -143,6 +143,7 @@ const TiptapEditorRuntime = forwardRef<NoteEditorHandle, RuntimeTiptapEditorProp
       isReady: () => baseRef.current?.isReady?.() ?? Boolean(baseRef.current),
       insertMarkdownAtCursor: (markdown) => baseRef.current?.insertMarkdownAtCursor?.(markdown) ?? false,
       appendMarkdown: (markdown) => baseRef.current?.appendMarkdown?.(markdown) ?? false,
+      applyCjkTypography: (action) => baseRef.current?.applyCjkTypography?.(action) ?? false,
     }), []);
 
     useEffect(() => {
diff --git a/frontend/src/components/editors/types.ts b/frontend/src/components/editors/types.ts
index 56b3a8151..41f4459ab 100644
--- a/frontend/src/components/editors/types.ts
+++ b/frontend/src/components/editors/types.ts
@@ -12,6 +12,7 @@
 
 import type { Note, Tag } from "@/types";
 import type * as Y from "yjs";
+import type { CjkTypographyAction } from "@/lib/cjkTypography";
 import type { Awareness } from "y-protocols/awareness";
 
 /** 标题项（大纲/跳转用） */
@@ -81,6 +82,8 @@ export interface NoteEditorProps {
 export interface NoteEditorHandle {
   /** 立即触发一次 onUpdate（跳过 debounce）。无 pending 更新时为 no-op。 */
   flushSave: () => void;
+  /** Manually apply a protected CJK typography action as one undoable edit. */
+  applyCjkTypography?: (action: CjkTypographyAction) => boolean;
   /**
    * 丢弃 pending 的 debounce 更新（清 timer，不派发 onUpdate）。
    * 用于"切换编辑器"这类场景：调用方已经自己以规范化后的内容发起 PUT，
diff --git a/frontend/src/hooks/__tests__/useAttachmentImageRenderSource.test.tsx b/frontend/src/hooks/__tests__/useAttachmentImageRenderSource.test.tsx
index 320e61d28..df15acf68 100644
--- a/frontend/src/hooks/__tests__/useAttachmentImageRenderSource.test.tsx
+++ b/frontend/src/hooks/__tests__/useAttachmentImageRenderSource.test.tsx
@@ -97,8 +97,11 @@ describe("useAttachmentImageRenderSource", () => {
 
     expect(apiMock.resolveAttachmentUrl).toHaveBeenCalledWith(rawSrc);
     expect(probe().dataset.persistentSrc).toBe(`/api/attachments/${ATTACHMENT_ID}`);
-    expect(new URL(probe().dataset.renderSrc!).searchParams.get("w")).toBe("320");
-    expect(new URL(probe().dataset.renderSrc!).searchParams.get("sig")).toBeNull();
+    // An unsigned private attachment must NEVER be exposed as an <img> URL.
+    // The original test expected the pre-auth URL to be renderable, which
+    // contradicts the existing verified-attachment-access security boundary.
+    expect(probe().dataset.renderSrc).toBe("");
+    expect(probe().dataset.error).toBe("1");
 
     await act(async () => {
       registerAttachmentAccessUrls(
diff --git a/frontend/src/i18n/coverageTranslations.ts b/frontend/src/i18n/coverageTranslations.ts
index ca82f094e..43ac72b63 100644
--- a/frontend/src/i18n/coverageTranslations.ts
+++ b/frontend/src/i18n/coverageTranslations.ts
@@ -179,6 +179,13 @@ export const zhCNCoverageTranslations = {
     "automaticHint": "常用地址不可达时，仅在 Wi-Fi 下尝试经过服务器身份验证的局域网地址。",
     "verifyFirst": "请先通过已保存地址连接一次，确认服务器身份后即可自动切换。",
   },
+  cjkTypography: {
+    "title": "中文排版",
+    "spacing": "中英文 / 数字间加空格",
+    "punctuation": "智能标点规范化",
+    "cornerQuotes": "转换为直角引号",
+    "noChanges": "没有可调整的内容，或当前编辑模式不支持此操作",
+  },
   syncBadge: {
     "conflicts": "{{count}} 个冲突待处理",
     "pending": "待同步 {{count}}",
@@ -771,6 +778,13 @@ export const enCoverageTranslations = {
     "automaticHint": "If the preferred address is unreachable, try a verified local network address only when connected to Wi-Fi.",
     "verifyFirst": "Connect through the saved address once to verify the server identity before automatic switching.",
   },
+  cjkTypography: {
+    "title": "Chinese typography",
+    "spacing": "Space between CJK and English / numbers",
+    "punctuation": "Normalize punctuation",
+    "cornerQuotes": "Convert to corner quotation marks",
+    "noChanges": "Nothing to change, or this editor mode does not support the operation",
+  },
   syncBadge: {
     "conflicts": "{{count}} conflicts to resolve",
     "pending": "{{count}} pending changes",
diff --git a/frontend/src/lib/__tests__/cjkTypography.test.ts b/frontend/src/lib/__tests__/cjkTypography.test.ts
new file mode 100644
index 000000000..51d1d80a5
--- /dev/null
+++ b/frontend/src/lib/__tests__/cjkTypography.test.ts
@@ -0,0 +1,138 @@
+// @vitest-environment jsdom
+import { describe, expect, it } from "vitest";
+import { EditorState, EditorSelection } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { history, undo } from "@codemirror/commands";
+import { Editor } from "@tiptap/react";
+import StarterKit from "@tiptap/starter-kit";
+import { transformCjkTypography } from "@/lib/cjkTypography";
+import { applyMarkdownCjkTypography } from "@/lib/markdownCommands";
+import { applyTiptapCjkTypography } from "@/lib/tiptapCjkTypography";
+
+describe("#822 manual Chinese typography", () => {
+  it("inserts spaces only at Han / Latin and digit boundaries", () => {
+    expect(transformCjkTypography("使用PostgreSQL数据库；2024年10月1日", "spacing"))
+      .toBe("使用 PostgreSQL 数据库；2024 年 10 月 1 日");
+    expect(transformCjkTypography("hello, world (参见图1)", "spacing"))
+      .toBe("hello, world (参见图 1)");
+  });
+
+  it("protects fenced code, inline code, TeX, URLs, email, HTML and Markdown destinations", () => {
+    const tick = String.fromCharCode(96);
+    const md = [
+      "使用PostgreSQL数据库，打开[网址介绍](https://example.com/中文doc?q=1.0)看文档",
+      "联系 dev中文@example.com 或访问 https://example.com/中文code",
+      "内联"+tick+"code中文ABC"+tick+" 保持",
+      "公式$E=mc中文2$与\\(a中文3\\)不改",
+      "<span class='中文ABC'>内容ABC</span>",
+      tick.repeat(3)+"javascript", "const name = '中文ABC';", tick.repeat(3),
+      "最后English版本",
+    ].join("\n");
+    const changed = transformCjkTypography(md, "spacing", "markdown");
+    expect(changed).toContain("使用 PostgreSQL 数据库");
+    expect(changed).toContain("网址介绍](https://example.com/中文doc?q=1.0)");
+    expect(changed).toContain("dev中文@example.com");
+    expect(changed).toContain("https://example.com/中文code");
+    expect(changed).toContain(tick+"code中文ABC"+tick);
+    expect(changed).toContain("$E=mc中文2$");
+    expect(changed).toContain("\\(a中文3\\)");
+    expect(changed).toContain("<span class='中文ABC'>");
+    expect(changed).toContain("const name = '中文ABC';");
+    expect(changed).toContain("最后 English 版本");
+  });
+
+  it("preserves frontmatter and Nowen note/mindmap reference identifiers", () => {
+    const md = "---\ntitle: 使用PostgreSQL笔记\n---\n见[[使用PostgreSQL笔记]]或![[mindmap:中文ABC]]和[^脚注A]。";
+    const result = transformCjkTypography(md, "spacing", "markdown");
+    expect(result).toContain("title: 使用PostgreSQL笔记");
+    expect(result).toContain("[[使用PostgreSQL笔记]]");
+    expect(result).toContain("![[mindmap:中文ABC]]");
+    expect(result).toContain("[^脚注A]");
+  });
+
+  it("normalizes Chinese punctuation but keeps English clauses and numeric tokens", () => {
+    expect(transformCjkTypography("你好,今天很好!欢迎(大家).", "punctuation"))
+      .toBe("你好，今天很好！欢迎（大家）。");
+    expect(transformCjkTypography("他说，Hello, world! 然后离开了。", "punctuation"))
+      .toBe("他说，Hello, world! 然后离开了。");
+    expect(transformCjkTypography("Hello， world！", "punctuation"))
+      .toBe("Hello, world!");
+    const numbers = transformCjkTypography("价格3.14,版本v1.0;时间10:30;总数1,000", "punctuation");
+    expect(numbers).toContain("3.14");
+    expect(numbers).toContain("v1.0");
+    expect(numbers).toContain("10:30");
+    expect(numbers).toContain("1,000");
+  });
+
+  it("keeps inline and block math untouched in rich-text text nodes", () => {
+    expect(transformCjkTypography("公式$E中文2$混排", "spacing"))
+      .toBe("公式$E中文2$混排");
+    expect(transformCjkTypography("公式\\(x中文3\\)不应改写", "spacing"))
+      .toBe("公式\\(x中文3\\)不应改写");
+  });
+
+  it("converts only matched quotation pairs and skips apostrophes", () => {
+    expect(transformCjkTypography('“外层‘内层’”', "cornerQuotes"))
+      .toBe("「外层『内层』」");
+    expect(transformCjkTypography('"外层\'内层\'"', "cornerQuotes"))
+      .toBe("「外层『内层』」");
+    expect(transformCjkTypography("don't students' said 'ok'", "cornerQuotes"))
+      .toContain("don't students'");
+    expect(transformCjkTypography('没有闭合的"引号', "cornerQuotes"))
+      .toBe('没有闭合的"引号');
+  });
+
+  it("is idempotent after a single manual action", () => {
+    for (const action of ["spacing", "punctuation", "cornerQuotes"] as const) {
+      const once = transformCjkTypography('他用PostgreSQL, 说“你好”', action);
+      expect(transformCjkTypography(once, action)).toBe(once);
+    }
+  });
+
+  it("CodeMirror edits only the selection and undoes all changes in one step", () => {
+    const source = "第一行PostgreSQL测试\n第二行SQLite数据库";
+    const host = document.createElement("div");
+    document.body.append(host);
+    const view = new EditorView({ parent: host, state: EditorState.create({
+      doc: source, extensions: [history()],
+    }) });
+    view.dispatch({ selection: EditorSelection.create([EditorSelection.range(0, source.indexOf("\n"))]) });
+    expect(applyMarkdownCjkTypography(view, "spacing")).toBe(true);
+    expect(view.state.doc.toString()).toBe("第一行 PostgreSQL 测试\n第二行SQLite数据库");
+    expect(undo(view)).toBe(true);
+    expect(view.state.doc.toString()).toBe(source);
+    view.destroy(); host.remove();
+  });
+
+  it("CodeMirror protects a selection placed inside inline code", () => {
+    const tick = String.fromCharCode(96);
+    const source = "普通中文ABC "+tick+"代码PostgreSQL测试"+tick+" 结束";
+    const host = document.createElement("div");
+    document.body.append(host);
+    const view = new EditorView({ parent: host, state: EditorState.create({
+      doc: source, extensions: [history()],
+    }) });
+    view.dispatch({ selection: EditorSelection.create([EditorSelection.range(0, source.length)]) });
+    expect(applyMarkdownCjkTypography(view, "spacing")).toBe(true);
+    expect(view.state.doc.toString()).toContain(tick+"代码PostgreSQL测试"+tick);
+    expect(undo(view)).toBe(true);
+    expect(view.state.doc.toString()).toBe(source);
+    view.destroy(); host.remove();
+  });
+
+  it("Tiptap preserves marks and code nodes and supports one-step undo", () => {
+    const element = document.createElement("div");
+    document.body.append(element);
+    const editor = new Editor({ element, extensions: [StarterKit],
+      content: '<p><strong>使用PostgreSQL数据库</strong> <code>代码Python片段</code></p><pre><code>代码ABC</code></pre><p>结尾</p>',
+    });
+    const before = editor.getHTML();
+    expect(applyTiptapCjkTypography(editor, "spacing")).toBe(true);
+    expect(editor.getHTML()).toContain("<strong>使用 PostgreSQL 数据库</strong>");
+    expect(editor.getHTML()).toContain("<code>代码Python片段</code>");
+    expect(editor.getHTML()).toContain("代码ABC");
+    expect(editor.commands.undo()).toBe(true);
+    expect(editor.getHTML()).toBe(before);
+    editor.destroy(); element.remove();
+  });
+});
diff --git a/frontend/src/lib/__tests__/markdownLivePreview.test.tsx b/frontend/src/lib/__tests__/markdownLivePreview.test.tsx
index 6e0df0b1f..cb4245246 100644
--- a/frontend/src/lib/__tests__/markdownLivePreview.test.tsx
+++ b/frontend/src/lib/__tests__/markdownLivePreview.test.tsx
@@ -67,14 +67,16 @@ describe("markdownLivePreviewExtension", () => {
       extensions: [markdown(), scope.of(markdownLivePreviewNoteId.of("note-a")), markdownLivePreviewExtension],
     }) });
     try {
-      await flushPreview();
-      expect(parent.querySelector("img")?.getAttribute("src")).toContain("sig=note-a");
+      await vi.waitFor(() => {
+        // CodeMirror widgets mount their React subtree asynchronously.
+        expect(parent.querySelector("img")?.getAttribute("src")).toContain("sig=note-a");
+      }, { timeout: 2500 });
       view.dispatch({ effects: scope.reconfigure(markdownLivePreviewNoteId.of("note-b")) });
-      await flushPreview();
       resetAttachmentAccessStateForTests();
-      await flushPreview();
-      expect(fetch.mock.calls.some(([url]) => String(url).includes("noteId=note-b"))).toBe(true);
-      expect(parent.querySelector("img")?.getAttribute("src")).toContain("sig=note-b");
+      await vi.waitFor(() => {
+        expect(fetch.mock.calls.some(([url]) => String(url).includes("noteId=note-b"))).toBe(true);
+        expect(parent.querySelector("img")?.getAttribute("src")).toContain("sig=note-b");
+      }, { timeout: 2500 });
       expect(view.state.doc.toString()).toBe(doc);
     } finally { view.destroy(); }
   });
diff --git a/frontend/src/lib/cjkTypography.ts b/frontend/src/lib/cjkTypography.ts
new file mode 100644
index 000000000..49cb78216
--- /dev/null
+++ b/frontend/src/lib/cjkTypography.ts
@@ -0,0 +1,245 @@
+/**
+ * Manual, dependency-free CJK typography tools.
+ * NEVER run on editor keystrokes. Ranges are evaluated in the original document
+ * so Markdown syntax is never re-created from rendered HTML.
+ */
+export type CjkTypographyAction = 'spacing' | 'punctuation' | 'cornerQuotes';
+export type CjkTypographyFormat = 'plain' | 'markdown';
+export interface TextRange { from: number; to: number }
+
+const HAN = /\p{Script=Han}/u;
+const TICK = String.fromCharCode(96);
+
+function mergeRanges(input: TextRange[]): TextRange[] {
+  const ranges = input.filter((r) => r.from < r.to).sort((a, b) => a.from - b.from || a.to - b.to);
+  const merged: TextRange[] = [];
+  for (const range of ranges) {
+    const last = merged[merged.length - 1];
+    if (last && range.from <= last.to) last.to = Math.max(last.to, range.to);
+    else merged.push({ ...range });
+  }
+  return merged;
+}
+
+function escapedAt(text: string, at: number): boolean {
+  let escapes = 0;
+  for (let i = at - 1; i >= 0 && text[i] === '\\'; i--) escapes++;
+  return escapes % 2 === 1;
+}
+
+export function markdownProtectedRanges(text: string): TextRange[] {
+  const ranges: TextRange[] = [];
+  // Fences and display math span multiple lines and must take precedence over
+  // inline parsing (including unmatched backticks in a code sample).
+  let offset = 0;
+  let fence: { char: string; size: number } | null = null;
+  let displayMath = false;
+  for (const line of text.split('\n')) {
+    const start = offset;
+    const end = offset + line.length + (offset + line.length < text.length ? 1 : 0);
+    const marker = line.match(/^ {0,3}(\x60{3,}|~{3,})/);
+    if (fence) {
+      ranges.push({ from: start, to: end });
+      if (marker && marker[1][0] === fence.char && marker[1].length >= fence.size &&
+          line.slice(marker[0].length).trim() === '') fence = null;
+    } else if (marker) {
+      fence = { char: marker[1][0], size: marker[1].length };
+      ranges.push({ from: start, to: end });
+    } else if (displayMath || /^\s*\$\$/.test(line)) {
+      ranges.push({ from: start, to: end });
+      const delimiters = line.match(/\$\$/g)?.length || 0;
+      if (!displayMath) displayMath = delimiters % 2 !== 0;
+      else if (delimiters % 2 !== 0) displayMath = false;
+    }
+    offset = end;
+  }
+
+  const alreadyProtected = (at: number) => ranges.some((r) => at >= r.from && at < r.to);
+  function addMatches(regex: RegExp) {
+    for (const match of text.matchAll(regex)) {
+      const from = match.index;
+      if (alreadyProtected(from)) continue;
+      ranges.push({ from, to: from + match[0].length });
+    }
+  }
+
+  // Entire link destination, including nested parentheses and optional title,
+  // while keeping the visible [label] available for typography.
+  for (let i = 0; i < text.length - 1; i++) {
+    if (text[i] !== ']' || text[i + 1] !== '(' || alreadyProtected(i)) continue;
+    let depth = 1;
+    let j = i + 2;
+    while (j < text.length && text[j] !== '\n' && depth > 0) {
+      if (!escapedAt(text, j)) {
+        if (text[j] === '(') depth++;
+        if (text[j] === ')') depth--;
+      }
+      j++;
+    }
+    if (depth === 0) {
+      ranges.push({ from: i + 1, to: j });
+      i = j - 1;
+    }
+  }
+
+  // Protect non-prose metadata and Nowen-style links: changing a link target
+  // would silently invalidate embedded notes/mind maps.
+  if (/^---\r?\n/.test(text)) {
+    const frontmatter = text.match(/^---\r?\n[\s\S]*?\n---[ \t]*(?:\r?\n|$)/);
+    if (frontmatter) ranges.push({ from: 0, to: frontmatter[0].length });
+  }
+  addMatches(/!?\[\[[^\]\n]+\]\]/g);
+  addMatches(/\[\^[^\]\n]+\]/g);
+
+  // URLs, emails, HTML tags and numeric tokens protected before punctuation.
+  addMatches(/<\/?[A-Za-z][^>\n]*>/g);
+  addMatches(/(?:https?:\/\/|www\.)[^\s<>()[\]"']+/gi);
+  addMatches(/[^\s<>()[\]"'@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g);
+  addMatches(/(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}(?:\/[^\s]*)?/g);
+  addMatches(/\b[vV]?\d+(?:[.,:]\d+)+(?:-[A-Za-z0-9]+)?\b/g);
+  addMatches(/\.{3,}/g);
+  addMatches(/^[ \t]{0,3}\[[^\]\n]+\]:[ \t]*[^\n]+/gm);
+
+  // Per-character parsing must not linearly scan thousands of protected
+  // ranges for every character in a large notebook.
+  const staticProtection = mergeRanges(ranges);
+  let protectedCursor = 0;
+  const isStaticProtected = (position: number) => {
+    while (protectedCursor < staticProtection.length &&
+           staticProtection[protectedCursor].to <= position) protectedCursor++;
+    const range = staticProtection[protectedCursor];
+    return !!range && position >= range.from && position < range.to;
+  };
+
+  // Inline code, math and TeX bracket delimiters. Keep unmatched openers
+  // untouched rather than stripping a delimiter or consuming following text.
+  for (let i = 0; i < text.length; i++) {
+    if (isStaticProtected(i) || escapedAt(text, i)) continue;
+    if (text[i] === TICK) {
+      let size = 1;
+      while (text[i + size] === TICK) size++;
+      const marker = TICK.repeat(size);
+      let end = text.indexOf(marker, i + size);
+      while (end >= 0 && (text[end + size] === TICK || escapedAt(text, end))) {
+        end = text.indexOf(marker, end + size);
+      }
+      if (end >= 0) {
+        ranges.push({ from: i, to: end + size });
+        i = end + size - 1;
+      } else i += size - 1;
+      continue;
+    }
+    const open = text.startsWith('\\(', i) ? '\\('
+      : text.startsWith('\\[', i) ? '\\['
+      : text[i] === '$' ? (text[i + 1] === '$' ? '$$' : '$') : null;
+    if (!open) continue;
+    const close = open === '\\(' ? '\\)' : open === '\\[' ? '\\]' : open;
+    let end = text.indexOf(close, i + open.length);
+    while (end >= 0 && escapedAt(text, end) && open[0] === '$') {
+      end = text.indexOf(close, end + close.length);
+    }
+    if (end >= 0 && (open !== '$' || text.slice(i + 1, end).trim())) {
+      ranges.push({ from: i, to: end + close.length });
+      i = end + close.length - 1;
+    }
+  }
+  return mergeRanges(ranges);
+}
+
+function addCjkSpacing(text: string): string {
+  return text.replace(/(\p{Script=Han})(?=[A-Za-z0-9])/gu, '$1 ')
+    .replace(/([A-Za-z0-9])(?=\p{Script=Han})/gu, '$1 ');
+}
+
+const TO_CJK: Record<string, string> = {
+  ',': '，', '.': '。', ';': '；', ':': '：',
+  '?': '？', '!': '！', '(': '（', ')': '）',
+};
+const TO_ASCII: Record<string, string> = Object.fromEntries(
+  Object.entries(TO_CJK).map(([en, zh]) => [zh, en]),
+);
+
+function isEnglishClause(text: string, pos: number): boolean {
+  const left = text.slice(Math.max(0, pos - 56), pos);
+  const right = text.slice(pos + 1, pos + 56);
+  const latinBefore = /[A-Za-z]$/.test(left);
+  const latinAfter = /^[ \t]*[A-Za-z]/.test(right);
+  if (latinBefore && latinAfter) return true;
+  const fragment = left.split(/[\p{Script=Han}，。！？；：\n]/u).pop() || '';
+  // "Hello, world!" in a Chinese paragraph remains an English clause.
+  return latinBefore && (fragment.match(/[A-Za-z]+/g)?.length || 0) >= 2;
+}
+
+function normalizePunctuation(text: string): string {
+  return text.split(/(\n)/).map((line) => {
+    if (line === '\n') return line;
+    const hans = [...line].filter((c) => HAN.test(c)).length;
+    const latins = [...line].filter((c) => /[A-Za-z]/.test(c)).length;
+    const chinese = hans >= 2 && hans >= latins * 0.35;
+    if (!chinese) {
+      if (hans > 0) return line; // mixed but ambiguous: do not guess
+      return [...line].map((c) => TO_ASCII[c] ?? c).join('');
+    }
+    return [...line].map((char, i) => {
+      if (!(char in TO_CJK)) return char;
+      if (isEnglishClause(line, i)) return char;
+      if (char === '.') {
+        if (/[A-Za-z0-9]/.test(line[i - 1] || '') || /[A-Za-z0-9]/.test(line[i + 1] || '')) return char;
+      }
+      if (char === '(' && /[A-Za-z]/.test(line[i + 1] || '')) return char;
+      if (char === ')' && /[A-Za-z]/.test(line[i - 1] || '')) return char;
+      return TO_CJK[char];
+    }).join('');
+  }).join('');
+}
+
+function convertQuotes(text: string): string {
+  const chars = [...text];
+  const pair = new Map<number, string>();
+  const stacks: Record<string, number[]> = { double: [], single: [] };
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+    const kind = /["“”]/.test(char) ? 'double' : /['‘’]/.test(char) ? 'single' : '';
+    if (!kind) continue;
+    const previous = chars[i - 1] || '';
+    const next = chars[i + 1] || '';
+    if (kind === 'single' && /[A-Za-z]/.test(previous) &&
+      (/[A-Za-z]/.test(next) || !stacks.single.length)) continue;
+    const openings = kind === 'double' ? '“' : '‘';
+    const closings = kind === 'double' ? '”' : '’';
+    const open = char === openings || (char !== closings && stacks[kind].length === 0);
+    if (open) stacks[kind].push(i);
+    else if (stacks[kind].length) {
+      const start = stacks[kind].pop()!;
+      pair.set(start, kind === 'double' ? '「' : '『');
+      pair.set(i, kind === 'double' ? '」' : '』');
+    }
+  }
+  return chars.map((char, i) => pair.get(i) ?? char).join('');
+}
+
+function plainTransform(text: string, action: CjkTypographyAction): string {
+  if (action === 'spacing') return addCjkSpacing(text);
+  if (action === 'punctuation') return normalizePunctuation(text);
+  return convertQuotes(text);
+}
+
+export function transformCjkTypography(
+  text: string, action: CjkTypographyAction, format: CjkTypographyFormat = 'plain',
+): string {
+  if (!text) return text;
+  const protectedRanges = format === 'markdown' ? markdownProtectedRanges(text) : [];
+  // In plain-text contexts avoid changing numeric, URLs and emails too.
+  if (format === 'plain') {
+    const re = /(?:https?:\/\/|www\.)[^\s<>()[\]"']+|[^\s<>()[\]"'@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}|\b[vV]?\d+(?:[.,:]\d+)+(?:-[A-Za-z0-9]+)?\b|\.{3,}|\\\([^\n]*?\\\)|\\\[[^\n]*?\\\]|\$\$[^$]*\$\$|\$[^$\n]+\$/gi;
+    for (const m of text.matchAll(re)) protectedRanges.push({ from: m.index, to: m.index + m[0].length });
+  }
+  let result = '';
+  let offset = 0;
+  for (const range of mergeRanges(protectedRanges)) {
+    result += plainTransform(text.slice(offset, range.from), action);
+    result += text.slice(range.from, range.to);
+    offset = range.to;
+  }
+  return result + plainTransform(text.slice(offset), action);
+}
diff --git a/frontend/src/lib/markdownCommands.ts b/frontend/src/lib/markdownCommands.ts
index 18360b1f8..44f338044 100644
--- a/frontend/src/lib/markdownCommands.ts
+++ b/frontend/src/lib/markdownCommands.ts
@@ -10,6 +10,8 @@
  */
 import { EditorView } from "@codemirror/view";
 import { EditorSelection, Line } from "@codemirror/state";
+import { isolateHistory } from "@codemirror/commands";
+import { transformCjkTypography, markdownProtectedRanges, type CjkTypographyAction } from "./cjkTypography";
 
 // ---------------------------------------------------------------------------
 // 基础工具
@@ -330,3 +332,37 @@ export function replaceSelection(view: EditorView, text: string): boolean {
   focus(view);
   return true;
 }
+
+
+/**
+ * One CodeMirror transaction for all changes, so Mod-Z rolls back the entire
+ * action. Protection ranges are read from the WHOLE original document, even
+ * when the current selection is only a substring of a code span/link URL.
+ */
+export function applyMarkdownCjkTypography(view: EditorView, action: CjkTypographyAction): boolean {
+  if (!view.state.facet(EditorView.editable)) return false;
+  const original = view.state.doc.toString();
+  const protectedRanges = markdownProtectedRanges(original);
+  const selections = view.state.selection.ranges;
+  const targets = selections.some((range) => range.from !== range.to)
+    ? selections.filter((range) => range.from !== range.to)
+    : [{ from: 0, to: original.length }];
+  const changes: Array<{ from: number; to: number; insert: string }> = [];
+  for (const range of targets) {
+    let cursor = range.from;
+    const cuts = protectedRanges.filter((block) => block.to > range.from && block.from < range.to);
+    for (const block of [...cuts, { from: range.to, to: range.to }]) {
+      const end = Math.min(block.from, range.to);
+      if (end > cursor) {
+        const text = original.slice(cursor, end);
+        const insert = transformCjkTypography(text, action);
+        if (insert !== text) changes.push({ from: cursor, to: end, insert });
+      }
+      cursor = Math.max(cursor, Math.min(block.to, range.to));
+    }
+  }
+  if (!changes.length) return false;
+  view.dispatch({ changes, annotations: isolateHistory.of("full"), userEvent: "input" });
+  focus(view);
+  return true;
+}
diff --git a/frontend/src/lib/tiptapCjkTypography.ts b/frontend/src/lib/tiptapCjkTypography.ts
new file mode 100644
index 000000000..e68ee7bf6
--- /dev/null
+++ b/frontend/src/lib/tiptapCjkTypography.ts
@@ -0,0 +1,36 @@
+import type { Editor } from "@tiptap/core";
+import type { Mark } from "@tiptap/pm/model";
+import { transformCjkTypography, type CjkTypographyAction } from "./cjkTypography";
+
+/**
+ * Transform *text nodes*, not HTML/JSON serialization. Preserve marks,
+ * embedded nodes, links, code and math. All replacements share one PM transaction.
+ */
+export function applyTiptapCjkTypography(editor: Editor, action: CjkTypographyAction): boolean {
+  if (!editor.isEditable || editor.isDestroyed) return false;
+  const { doc, selection } = editor.state;
+  const hasSelection = !selection.empty;
+  const from = hasSelection ? selection.from : 0;
+  const to = hasSelection ? selection.to : doc.content.size;
+  const patches: Array<{ from: number; to: number; text: string; marks: readonly Mark[] }> = [];
+  doc.nodesBetween(from, to, (node, pos, parent) => {
+    const type = node.type.name.toLowerCase();
+    if (/(?:codeblock|code_block|math|formula|equation|diagram|mermaid)/.test(type)) return false;
+    if (!node.isText || !node.text) return;
+    if (parent && /(?:codeblock|code_block|math|formula)/.test(parent.type.name.toLowerCase())) return;
+    if (node.marks.some((mark) => /^(?:code|link|math|inlineMath)$/i.test(mark.type.name))) return;
+    const start = Math.max(from, pos);
+    const end = Math.min(to, pos + node.nodeSize);
+    if (end <= start) return;
+    const source = node.text.slice(start - pos, end - pos);
+    const text = transformCjkTypography(source, action);
+    if (source !== text) patches.push({ from: start, to: end, text, marks: node.marks });
+  });
+  if (!patches.length) return false;
+  const transaction = editor.state.tr;
+  for (const patch of patches.reverse()) {
+    transaction.replaceWith(patch.from, patch.to, editor.schema.text(patch.text, patch.marks));
+  }
+  editor.view.dispatch(transaction.scrollIntoView());
+  return true;
+}