diff --git a/PROGRESS.md b/PROGRESS.md
index e26d7ed..0b57a96 100644
--- a/PROGRESS.md
+++ b/PROGRESS.md
@@ -6,11 +6,12 @@
 
 | 工作流 | 状态 | 完成度 | 下一检查点 |
 |---|---:|---:|---|
-| 研究框架与规范 | 进行中 | 72% | 给 125 篇索引补充逐篇精读层级 |
+| 研究框架与规范 | 进行中 | 76% | 给 130 篇索引补充逐篇精读层级 |
 | 网站设计系统 | 进行中 | 89% | 打印样式与更多通用可视化组件 |
 | Kimi K3 深读 | 进行中 | 55% | 扩写 scaling / infra 逐图笔记 |
 | Transformer 基础 | 进行中 | 52% | 矩阵形状动画与手算练习 |
 | DeepSeek 专题 | 进行中 | 61% | GRPO 完整公式与训练轨迹推导 |
+| 稀疏计算与 MoE | 完成首版 | 74% | 真实负载 traces 与专家特化案例 |
 | 长上下文专题 | 完成首版 | 72% | 真实模型配置、内核细节与失败案例 |
 | 引用与事实检查 | 进行中 | 54% | 自动化外链复查与来源等级扩展 |
 | 开源仓库 | 已完成首版 | 100% | 持续提交研究与网站迭代 |
@@ -25,21 +26,24 @@
 - [x] 提炼参考网站的编辑设计语言。
 - [x] 确认 `git.k1412.top` 为 Gitea/Forgejo 兼容服务且本机 HTTPS 凭据可用于既有仓库。
 - [x] 使用 Grok CLI 检索并形成约 95 篇一手论文的补充路线，主代理已回查关键来源。
-- [x] 完成首批 125 篇关键论文索引，覆盖 12 个专题与 Kimi/DeepSeek 聚光主线。
+- [x] 完成首批 130 篇关键论文索引，覆盖 12 个专题与 Kimi/DeepSeek 聚光主线。
 - [x] 完成可检索、可按专题筛选的论文库页面。
-- [x] 完成 K3、Transformer 基础、DeepSeek 谱系与长上下文四篇首版长文。
-- [x] 完成 K3 三轴架构、Self-Attention 实验、DeepSeek 谱系与长上下文成本实验室四张原创交互图。
+- [x] 完成 K3、Transformer 基础、DeepSeek 谱系、长上下文与 MoE 五篇首版长文。
+- [x] 完成 K3 三轴架构、Self-Attention 实验、DeepSeek 谱系、长上下文成本与 MoE 路由实验室五张原创交互图。
 - [x] 完成长上下文首版：五张成本账、26 篇一手论文、10+ 机制图与 8 策略交互实验室。
 - [x] 核验 FlashAttention、DeepSeek-V2/V3.2/V4、Kimi Linear/K3 等六份论文原文，并建立长上下文研究账本。
-- [x] Astro 类型检查、生产构建、8 个内部路由和桌面/移动端视觉检查通过。
+- [x] 核验 Switch、ST-MoE、DeepSeekMoE、Loss-Free、V3、LatentMoE 与 K3 原文，并建立 MoE 研究账本。
+- [x] 完成 MoE 首版：六张账、19 篇一手论文、完整 DeepSeek/K3 主线与路由—容量—通信实验室。
+- [x] Astro 类型检查、生产构建、9 个内部路由和桌面/移动端视觉检查通过。
 - [x] 创建 `wuyang/llm-atlas` 公开仓库，匿名 API 确认 `private: false`。
-- [x] 本地生产镜像通过健康检查与全部 8 个页面路由烟雾测试。
+- [x] 本地生产镜像通过健康检查与全部 9 个页面路由烟雾测试。
 - [x] 通过 Unraid Compose Manager、Nginx Proxy Manager 与 HTTPS 发布首版。
 
 ## 正在进行
 
-- [ ] MoE 路由模拟器与通信成本账本。
+- [ ] 推理模型与测试时扩展：CoT、verifier、GRPO、R1、Kimi k1.5 与 K3 MOPD。
 - [ ] 长上下文专题的真实模型配置对比、内核细节与失败案例二轮深化。
+- [ ] MoE 专题的真实集群 traces、专家特化案例与二轮外部证据。
 
 ## 研究账本
 
@@ -49,11 +53,13 @@
 | 2026-07-28 | K3 作为“汇流点”，不是课程起点 | 初学者可以先学基础，高阶读者可以从 K3 反向跳转 |
 | 2026-07-28 | 优先重绘论文图并标明“简化/改绘” | 图可缩放、可交互，也减少脱离上下文复制论文图片 |
 | 2026-07-28 | Grok 只用于线索扩展与交叉检查 | 正文事实必须回到论文、官方仓库或正式文档 |
-| 2026-07-28 | 首批论文库收录 125 篇，按问题与专题多标签组织 | 论文库承担发现入口，专题正文承担深度精读与机制复核 |
+| 2026-07-28 | 首批论文库收录 130 篇，按问题与专题多标签组织 | 论文库承担发现入口，专题正文承担深度精读与机制复核 |
 | 2026-07-28 | 源码公开到 `git.k1412.top/wuyang/llm-atlas` | 路线、进度、研究方法和内容变更均可追踪 |
 | 2026-07-28 | 站点使用不可变镜像与 Compose Manager 部署 | 每次发布保留明确版本、健康检查和回滚点 |
 | 2026-07-28 | 长上下文按计算、缓存、位置、状态容量、系统五张账单组织 | 避免把 FlashAttention、位置外推和“记住更久”混成同一个问题 |
 | 2026-07-28 | 交互缓存数字统一标记为教学估算 | 展示增长规律，不冒充任一模型的真实线上显存基准 |
+| 2026-07-28 | MoE 按六张账组织，路由算法与集群执行分开核算 | 避免用“稀疏所以便宜”跳过容量、负载、通信与权重读取 |
+| 2026-07-28 | “aux-loss-free”保留论文真实边界 | 区分 selection bias、mixture weight、z-loss 与 V3 的极小 sequence-wise loss |
 
 ## 未决问题
 
diff --git a/README.md b/README.md
index 89ab38f..a011fa1 100644
--- a/README.md
+++ b/README.md
@@ -17,8 +17,8 @@
 - 持续进度：[PROGRESS.md](./PROGRESS.md)
 - 证据与写作规范：[research/METHODOLOGY.md](./research/METHODOLOGY.md)
 
-首个里程碑包含 16 专题学习地图、125 篇关键论文索引、Kimi K3 完整导读、
-Transformer 基础、DeepSeek 技术谱系、长上下文与高效注意力深度专题，以及四张原创交互可视化。
+当前里程碑包含 16 专题学习地图、130 篇关键论文索引、Kimi K3 完整导读、
+Transformer 基础、DeepSeek 技术谱系、长上下文与 MoE 深度专题，以及五张原创交互可视化。
 其余专题按进度账本持续扩建。
 
 ## 本地开发
diff --git a/ROADMAP.md b/ROADMAP.md
index 6d88eea..61070fc 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -45,6 +45,9 @@ GPT 系列 → Kaplan scaling laws → Chinchilla compute-optimal → 数据质
 
 Conditional Computation → Sparsely-Gated MoE → GShard/Switch → DeepSeekMoE → LatentMoE → K3 Stable LatentMoE。重点解释路由、专家特化、负载均衡与通信。
 
+首版已发布：以“容量、激活计算、路由、负载、通信、稳定性”六张账串起 1991–2026 的 19 篇一手论文，
+包含 DeepSeekMoE / Loss-Free / LatentMoE / K3 重点推导，以及 8 种架构、4 类平衡策略的交互实验室。
+
 ### 07. 长上下文与高效注意力
 
 稀疏注意力、线性注意力、FlashAttention、MQA/GQA、MLA、状态空间模型、Delta Rule、Kimi Linear/KDA、混合注意力与 1M 上下文。
diff --git a/package.json b/package.json
index 767c119..0e70d59 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,9 @@
     "dev": "astro dev --host 0.0.0.0",
     "build": "astro build",
     "preview": "astro preview --host 0.0.0.0",
-    "check": "astro check"
+    "check": "astro check",
+    "check:site": "node scripts/check-site.mjs",
+    "check:moe-browser": "node scripts/check-moe-browser.mjs"
   },
   "dependencies": {
     "@astrojs/sitemap": "3.7.3",
diff --git a/research/MOE_RESEARCH.md b/research/MOE_RESEARCH.md
new file mode 100644
index 0000000..2a0e5e4
--- /dev/null
+++ b/research/MOE_RESEARCH.md
@@ -0,0 +1,159 @@
+# 稀疏计算与 MoE 研究账本
+
+最后核验：2026-07-28
+
+## 教学主线
+
+MoE 不能只写成“更多参数、较少计算”。本专题固定拆成六张账单：
+
+1. **容量**：模型一共存了多少参数。
+2. **激活计算**：每个 Token 实际经过多少专家参数。
+3. **路由**：谁决定 Token 去哪里，选择是 top-1、top-2 还是 top-k。
+4. **负载**：专家收到的 Token 是否均匀，溢出时是否丢 Token。
+5. **通信**：专家分散在不同设备后，dispatch / combine 两次 All-to-All 搬多少数据。
+6. **稳定性**：硬路由、router logits、极稀疏潜空间链怎样影响训练。
+
+核心因果链：
+
+> 稠密 FFN 把容量与每 Token 算力绑死  
+> → 软门控专家学会分工，但所有专家仍可能参与  
+> → 稀疏 top-k 让条件计算进入大规模模型  
+> → Transformer MoE 把 FFN 专家分到设备上  
+> → 容量、掉 Token、负载和 All-to-All 成为新瓶颈  
+> → DeepSeek 细分专家、隔离共享知识，并限制跨设备路由  
+> → 无辅助损失 bias 把均衡移出主梯度  
+> → LatentMoE 压缩路由载荷与专家宽度  
+> → K3 在 896 选 16 的极稀疏区间进一步解决激活爆炸、bias 更新和执行不均。
+
+## 本地一手材料
+
+PDF 与文本只作本地研究缓存，受 `.gitignore` 排除；公开仓库仅提交本账本和 canonical URL。
+
+| ID | 来源 | 本地页数 | 本轮用途 |
+|---|---|---:|---|
+| `1701.06538` | Sparsely-Gated MoE | 19 | Noisy Top-k 与现代稀疏门控起点 |
+| `2006.16668` | GShard | 35 | Transformer MoE、自动切分与 Top-2 |
+| `2101.03961` | Switch Transformers | 40 | Top-1、capacity factor、drop 与 EP |
+| `2202.08906` | ST-MoE | 38 | router z-loss、稳定性与迁移 |
+| `2202.09368` | Expert Choice | 14 | 专家选 Token 的负载均衡分支 |
+| `2401.04088` | Mixtral of Experts | 13 | 社区可运行的 8 选 2 MoE |
+| `2401.06066` | DeepSeekMoE | 33 | 细粒度专家与共享专家 |
+| `2408.15664` | Auxiliary-Loss-Free Balancing | 14 | expert bias 与干扰梯度 |
+| `2412.19437` | DeepSeek-V3 | 53 | 256 选 8、node limit、系统协同 |
+| `2601.18089` | LatentMoE | 18 | 潜空间专家、带宽与通信 |
+| `2607.24653` | Kimi K3 | 47 | Stable LatentMoE、QB 与 MoonEP |
+
+补充复用：
+
+- DeepSeek-V2 `2405.04434`：本地缓存位于 `research/sources/long-context/`。
+- Kimi K3 原报告：`research/sources/kimi-k3/k3_tech_report.*`。
+
+## 已核验的关键结论
+
+### Switch：capacity factor 不是模型容量
+
+Switch 的专家容量定义为：
+
+```text
+expert capacity = tokens per batch / number of experts × capacity factor
+```
+
+- 它是每个专家这一批最多能处理多少 Token，不是专家参数量。
+- 大于 1 的 capacity factor 提供负载缓冲。
+- 专家溢出时，Switch 跳过专家计算并让表示沿残差路径进入下一层。
+- capacity factor 增大也会增加 padding、计算、激活内存和通信。
+- 论文报告在其主要实验中 dropped tokens 通常低于 1%，不可外推为所有 MoE。
+
+### ST-MoE：稳定不等于均衡
+
+- Load-balancing loss 管“专家是否被均匀使用”。
+- Router z-loss 管“进入 router softmax 的 logits 是否过大”。
+- ST-MoE 的公式惩罚每个 Token router log-partition 的平方。
+- 论文的稳定性研究使用训练 CF=1.25、评估 CF=2.0，并令 z-loss 系数 `0.001`。
+- 因而 z-loss 不能被写成另一种负载均衡损失。
+
+### DeepSeekMoE：同计算预算下切得更细
+
+- 传统配置有 `N` 个专家、激活 `K` 个。
+- DeepSeekMoE 把每个 FFN 专家沿中间维切成 `m` 个更小专家，总数成为 `mN`，激活数成为 `mK`，保持总专家参数与激活计算近似不变。
+- 论文示例：`N=16, K=2` 只有 `C(16,2)=120` 种组合；切成 `64` 个小专家并激活 `8` 个后，组合数为 `C(64,8)=4,426,165,368`。
+- Shared expert isolation 让共享专家始终执行，承载共性变换；路由专家更专注于差异知识。
+- 2B 验证模型为 1 个共享专家 + 63 个路由专家，其中每 Token 激活 1+7。
+- 禁用共享专家并多激活一个路由专家时，论文的 Pile loss 从 1.808 上升到 2.414；这是该实验设置下的证据，不是通用常数。
+
+### Loss-Free / V3：selection 与 mixture weight 分开
+
+- 原始 affinity score 为 `s`，expert bias 为 `b`。
+- `s+b` 只用于决定 top-k；最终混合专家输出的权重仍来自原始 `s`。
+- 因此 bias 调整 dispatch，不向语言建模参数引入 auxiliary-loss 的干扰梯度。
+- 原方法按上一步负载以固定步长更新 bias；步长过小反应慢、过大会振荡。
+- DeepSeek-V3：671B 总参数、37B 激活；每个 MoE 层 1 shared + 256 routed，激活 8 routed；每 Token 最多发往 4 个节点。
+- V3 主要使用 auxiliary-loss-free 策略，但仍保留系数极小的 sequence-wise balance loss 防止单序列极端失衡。正文必须保留这个边界，不能简写为“完全没有任何辅助损失”。
+- V3 报告称训练和推理都不 drop Token；这是其负载均衡与部署策略下的模型报告事实。
+
+### LatentMoE：省下的是路由宽度与专家权重流量
+
+- 标准 MoE 以模型宽度 `d` dispatch Token，并让 routed expert 在 `d` 宽度上计算。
+- LatentMoE 先下投影到 `ℓ<d`，在 latent space dispatch、计算和 combine，再上投影回 `d`。
+- 共享专家仍可保留全宽路径。
+- 原论文称 routed parameter load 与 All-to-All traffic 可按 `d/ℓ` 比例降低。
+- `ℓ-MoE_eff` 主要把节省换成更多总专家；`ℓ-MoE_acc` 同时扩大总专家数与 top-k，以近似固定推理成本换精度，论文推荐后者作为 Pareto 方案。
+- 论文在 16B/2B active 与 95B/8B active 模型上验证，并把压缩比 `α=d/ℓ=4` 作为主要后续设置；“4× 可行”仍是该实验范围内的结论。
+- 论文中万亿参数 Kimi-K2 serving 比较来自性能模拟器与 effective-parameter construction，不是真实生产 A/B 基准。
+
+### K3：Stable LatentMoE 的“Stable”有明确内容
+
+K3 报告给出的配置：
+
+- 2.78T 总参数，104.2B 激活参数。
+- 896 个 routed experts，每 Token 激活 16 个。
+- 2 个 full-width shared experts。
+- hidden dimension 7168，latent MoE dimension 3584。
+- 每个 expert 的 MoE hidden dimension 3072。
+
+从 LatentMoE 到 Stable LatentMoE 的三项增量：
+
+1. routed expert 聚合后、上投影前加入 RMSNorm；
+2. 用有界的 SiTU-GLU 抑制连续矩阵乘链中的内部激活爆炸；
+3. 用 Quantile Balancing 替代固定步长 bias 更新。
+
+Quantile Balancing：
+
+- 每批 `m` 个 Token、`n` 个专家、top-k 时，目标负载为 `q=mk/n`。
+- 先算 Top-(k+1)，第 `k+1` 个分数给出每个 Token 进入 top-k 的 cutoff。
+- 对每个专家计算其 score 相对各 Token cutoff 的 margin，并取 `(1-k/n)` quantile 得到下一步 bias。
+- 更新只在下一训练步生效，避免用当前批的未来 Token 改当前路由。
+- 大规模实现不聚集全部 margin，而用每专家直方图 + 一次 all-reduce 估计全局 quantile。
+- 最终 bias 在推理阶段冻结。
+
+### MoonEP：算法均衡之后还有执行均衡
+
+- QB 使专家层面的目标负载更均衡，但专家部署到 EP ranks 后仍要解决设备执行不均。
+- MoonEP 为当前 micro-batch 与层在线规划 redundant experts。
+- K3 报告证明每 rank 预留至多 `E/R` 个冗余专家槽即可保证存在平衡计划。
+- 每个 rank 最终收到完全相同的 `S×K` Token 槽，形成 static shapes，消除每层 host sync。
+- fused permute/unpermute 让 Token 直接进入远端 expert-grouped buffer，减少中间 copy。
+- 这是模型路由、通信、内存与 kernel 调度的系统协同，不能只归功于 router 算法。
+
+## 关键边界
+
+- 总参数与激活参数口径可能是否包含 embedding、attention、shared expert；跨模型比较必须沿用各报告口径。
+- “激活专家比例 K/N”不等于“激活参数比例”，因为 attention、共享专家、投影和 embedding 仍是稠密路径。
+- 理论 FLOPs 不直接等于端到端延迟；小 batch 常受权重带宽限制，大 EP 常受 All-to-All 限制。
+- `C(N,K)` 只展示组合空间上限，不证明模型真的学到同等数量的有意义专业化模式。
+- Expert Choice 可实现专家侧固定容量，但对 causal LM 可能泄露同一 chunk 中未来 Token 对前面 Token 路由的影响；Loss-Free 论文给出明确讨论。
+- K3 的 104B activated parameters 不应被误写成 16/896×2.8T。
+- Grok CLI 只用于扩大候选论文与检查遗漏；以上机制和数字均回查原论文或 K3 官方报告。
+
+## 首版正文完成闸门
+
+- [x] 用一张图区分 total parameters、active parameters、FLOPs、weight traffic。
+- [x] 画出 route → dispatch → expert → combine 的两次 All-to-All。
+- [x] 让读者能手算 capacity factor 与 overflow。
+- [x] 把 aux loss、router z-loss、loss-free bias、Quantile Balancing 放在同一因果链。
+- [x] 单独重绘 DeepSeekMoE 细粒度与 shared expert。
+- [x] 单独推导 LatentMoE 的 `d→ℓ→d`。
+- [x] 交互实验室可切换 Switch、Mixtral、DeepSeekMoE/V3、LatentMoE 与 K3。
+- [x] 讲清 K3 的 RMSNorm、SiTU-GLU、QB 和 MoonEP，不把 Stable LatentMoE 缩成一行配置。
+- [x] 论文链全部指向一手来源。
+- [x] 类型、链接、交互、桌面/移动端和容器检查通过。
diff --git a/scripts/check-moe-browser.mjs b/scripts/check-moe-browser.mjs
new file mode 100644
index 0000000..e9cf88a
--- /dev/null
+++ b/scripts/check-moe-browser.mjs
@@ -0,0 +1,187 @@
+import { writeFileSync } from "node:fs";
+
+const cdpPort = process.env.CDP_PORT ?? "9223";
+const baseUrl = process.env.SITE_URL ?? "http://127.0.0.1:4322";
+const pages = await fetch(`http://127.0.0.1:${cdpPort}/json/list`).then((response) => response.json());
+const page = pages.find((entry) => entry.type === "page");
+if (!page) throw new Error(`CDP ${cdpPort} 没有可用页面`);
+
+const socket = new WebSocket(page.webSocketDebuggerUrl);
+await new Promise((resolve, reject) => {
+  socket.addEventListener("open", resolve, { once: true });
+  socket.addEventListener("error", reject, { once: true });
+});
+
+let nextId = 0;
+const pending = new Map();
+const exceptions = [];
+socket.addEventListener("message", (event) => {
+  const message = JSON.parse(event.data);
+  if (message.id && pending.has(message.id)) {
+    const { resolve, reject } = pending.get(message.id);
+    pending.delete(message.id);
+    if (message.error) reject(new Error(message.error.message));
+    else resolve(message.result);
+  }
+  if (message.method === "Runtime.exceptionThrown") {
+    exceptions.push(message.params.exceptionDetails.text);
+  }
+});
+
+const command = (method, params = {}) => new Promise((resolve, reject) => {
+  const id = ++nextId;
+  pending.set(id, { resolve, reject });
+  socket.send(JSON.stringify({ id, method, params }));
+});
+const pause = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const evaluate = async (expression) => {
+  const result = await command("Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true,
+  });
+  if (result.exceptionDetails) throw new Error(result.exceptionDetails.text);
+  return result.result.value;
+};
+const navigate = async (path) => {
+  await command("Page.navigate", { url: `${baseUrl}${path}` });
+  for (let attempt = 0; attempt < 30; attempt += 1) {
+    await pause(100);
+    if (await evaluate("document.readyState === 'complete'")) return;
+  }
+  throw new Error(`${path} 加载超时`);
+};
+const screenshot = async (path) => {
+  const result = await command("Page.captureScreenshot", { format: "png", captureBeyondViewport: false });
+  writeFileSync(path, Buffer.from(result.data, "base64"));
+};
+
+await command("Page.enable");
+await command("Runtime.enable");
+await command("Emulation.setDeviceMetricsOverride", {
+  width: 1440,
+  height: 1100,
+  deviceScaleFactor: 1,
+  mobile: false,
+});
+await navigate("/moe/");
+
+const k3 = await evaluate(`(() => {
+  const root = document.querySelector("[data-moe-lab]");
+  const started = performance.now();
+  root.querySelector('[data-preset-button="k3"]').click();
+  const duration = performance.now() - started;
+  const skew = root.querySelector("[data-skew]");
+  const capacity = root.querySelector("[data-capacity]");
+  skew.value = "100";
+  capacity.value = "0.75";
+  skew.dispatchEvent(new Event("input", { bubbles: true }));
+  capacity.dispatchEvent(new Event("input", { bubbles: true }));
+  root.querySelector('[data-balance="none"]').click();
+  const none = {
+    ratio: root.querySelector("[data-load-ratio]").textContent,
+    overflow: root.querySelector("[data-drop-rate]").textContent,
+  };
+  root.querySelector('[data-balance="quantile"]').click();
+  return {
+    duration: Number(duration.toFixed(2)),
+    title: root.querySelector("[data-route-title]").textContent,
+    fraction: root.querySelector("[data-active-fraction]").textContent,
+    communication: root.querySelector("[data-comm-value]").textContent,
+    communicationNote: root.querySelector("[data-comm-note]").textContent,
+    combination: root.querySelector("[data-combination-value]").textContent,
+    none,
+    quantile: {
+      ratio: root.querySelector("[data-load-ratio]").textContent,
+      overflow: root.querySelector("[data-drop-rate]").textContent,
+    },
+    metrics: root.querySelectorAll(".metric-grid > article").length,
+  };
+})()`);
+
+const latent = await evaluate(`(() => {
+  const root = document.querySelector("[data-moe-lab]");
+  const started = performance.now();
+  root.querySelector('[data-preset-button="latent"]').click();
+  return {
+    duration: Number((performance.now() - started).toFixed(2)),
+    fraction: root.querySelector("[data-active-fraction]").textContent,
+    communication: root.querySelector("[data-comm-value]").textContent,
+    note: root.querySelector("[data-comm-note]").textContent,
+  };
+})()`);
+
+const layout = await evaluate(`(() => {
+  const header = document.querySelector(".site-header");
+  const nav = document.querySelector(".top-nav");
+  const meta = document.querySelector(".header-meta");
+  return {
+    documentOverflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
+    navGap: Number((meta.getBoundingClientRect().left - nav.getBoundingClientRect().right).toFixed(1)),
+    articleSections: document.querySelectorAll(".article-section").length,
+  };
+})()`);
+
+await evaluate(`(() => {
+  document.documentElement.style.scrollBehavior = "auto";
+  document.querySelector("[data-moe-lab]").scrollIntoView({ block: "start", behavior: "instant" });
+  return { scrollY, top: document.querySelector("[data-moe-lab]").getBoundingClientRect().top };
+})()`);
+await pause(200);
+await screenshot("/tmp/llm-atlas-moe-lab-desktop.png");
+
+await command("Emulation.setDeviceMetricsOverride", {
+  width: 390,
+  height: 844,
+  deviceScaleFactor: 1,
+  mobile: true,
+});
+await navigate("/moe/");
+const mobile = await evaluate(`({
+  documentOverflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
+  menuVisible: getComputedStyle(document.querySelector("#menu-toggle")).display !== "none",
+  title: document.querySelector("h1").innerText,
+})`);
+await screenshot("/tmp/llm-atlas-moe-mobile.png");
+
+await command("Emulation.setDeviceMetricsOverride", {
+  width: 1440,
+  height: 1100,
+  deviceScaleFactor: 1,
+  mobile: false,
+});
+await navigate("/");
+const home = await evaluate(`({
+  documentOverflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
+  releaseCards: document.querySelectorAll(".release-card").length,
+  navLinks: document.querySelectorAll(".top-nav a").length,
+})`);
+await screenshot("/tmp/llm-atlas-home-desktop.png");
+await evaluate(`(() => {
+  document.documentElement.style.scrollBehavior = "auto";
+  document.querySelector("#new-chapters").scrollIntoView({ block: "start", behavior: "instant" });
+})()`);
+await pause(100);
+await screenshot("/tmp/llm-atlas-home-releases.png");
+
+const report = { k3, latent, layout, mobile, home, exceptions };
+console.log(JSON.stringify(report, null, 2));
+
+const failures = [];
+if (!k3.title.includes("896 选 16")) failures.push("K3 预设未生效");
+if (k3.metrics !== 6) failures.push(`指标卡数量异常：${k3.metrics}`);
+if (!k3.communicationNote.includes("2× latent")) failures.push("K3 latent 通信说明缺失");
+if (!latent.note.includes("4× latent")) failures.push("LatentMoE 4× 通信说明缺失");
+if (layout.documentOverflow > 0 || mobile.documentOverflow > 0 || home.documentOverflow > 0) {
+  failures.push("页面存在横向溢出");
+}
+if (layout.navGap < 0) failures.push(`桌面导航碰撞：${layout.navGap}px`);
+if (!mobile.menuVisible) failures.push("移动端菜单按钮未显示");
+if (home.releaseCards !== 2) failures.push(`首页新章卡数量异常：${home.releaseCards}`);
+if (exceptions.length) failures.push(`浏览器脚本异常：${exceptions.join("; ")}`);
+
+socket.close();
+if (failures.length) {
+  failures.forEach((failure) => console.error(`- ${failure}`));
+  process.exit(1);
+}
diff --git a/scripts/check-site.mjs b/scripts/check-site.mjs
new file mode 100644
index 0000000..ec766e8
--- /dev/null
+++ b/scripts/check-site.mjs
@@ -0,0 +1,67 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { extname, join, normalize } from "node:path";
+
+const root = new URL("../dist/", import.meta.url);
+const rootPath = root.pathname;
+
+function walk(directory) {
+  return readdirSync(directory).flatMap((name) => {
+    const path = join(directory, name);
+    return statSync(path).isDirectory() ? walk(path) : [path];
+  });
+}
+
+function routeFile(pathname) {
+  const clean = decodeURIComponent(pathname).replace(/^\/+/, "");
+  if (!clean) return join(rootPath, "index.html");
+  const local = normalize(join(rootPath, clean));
+  if (!local.startsWith(normalize(rootPath))) return null;
+  if (extname(local)) return local;
+  return join(local, "index.html");
+}
+
+if (!existsSync(rootPath)) {
+  console.error("dist/ 不存在；请先运行 npm run build。");
+  process.exit(1);
+}
+
+const htmlFiles = walk(rootPath).filter((file) => file.endsWith(".html"));
+const anchors = new Map();
+for (const file of htmlFiles) {
+  const html = readFileSync(file, "utf8");
+  anchors.set(file, new Set([...html.matchAll(/\sid=["']([^"']+)["']/g)].map((match) => match[1])));
+}
+
+let references = 0;
+let anchorReferences = 0;
+const failures = [];
+
+for (const source of htmlFiles) {
+  const html = readFileSync(source, "utf8");
+  const hrefs = [...html.matchAll(/\shref=["']([^"']+)["']/g)].map((match) => match[1]);
+  for (const href of hrefs) {
+    if (!href.startsWith("/") || href.startsWith("//")) continue;
+    references += 1;
+    const url = new URL(href, "https://llm-atlas.local");
+    const target = routeFile(url.pathname);
+    if (!target || !existsSync(target)) {
+      failures.push(`${source.replace(rootPath, "/")} → ${href}（目标不存在）`);
+      continue;
+    }
+    if (url.hash) {
+      anchorReferences += 1;
+      const id = decodeURIComponent(url.hash.slice(1));
+      if (!anchors.get(target)?.has(id)) {
+        failures.push(`${source.replace(rootPath, "/")} → ${href}（锚点不存在）`);
+      }
+    }
+  }
+}
+
+console.log(
+  `${htmlFiles.length} 个页面，${references} 个站内引用，${anchorReferences} 个跨页锚点，${failures.length} 个失败。`,
+);
+if (failures.length) {
+  failures.forEach((failure) => console.error(`- ${failure}`));
+  process.exit(1);
+}
diff --git a/src/components/MoERoutingLab.astro b/src/components/MoERoutingLab.astro
new file mode 100644
index 0000000..dcdfe2d
--- /dev/null
+++ b/src/components/MoERoutingLab.astro
@@ -0,0 +1,1298 @@
+---
+const presets = [
+  {
+    id: "dense",
+    label: "Dense FFN",
+    kicker: "1 条固定路径",
+    experts: 1,
+    active: 1,
+    shared: 0,
+    devices: 1,
+    deviceLimit: 1,
+    latentRatio: 1,
+    capacity: 1,
+    balance: "none",
+    summary: "每个 Token 都经过同一套 FFN 参数。容量、每 Token 算力与权重读取被绑在一起。",
+    solves: "执行简单、无路由",
+    leaves: "扩容量就同步扩计算",
+  },
+  {
+    id: "switch",
+    label: "Switch",
+    kicker: "128 选 1",
+    experts: 128,
+    active: 1,
+    shared: 0,
+    devices: 8,
+    deviceLimit: 8,
+    latentRatio: 1,
+    capacity: 1.25,
+    balance: "aux",
+    summary: "每个 Token 只去得分最高的一个专家，用最小 top-k 降低专家计算和通信。",
+    solves: "把容量与激活计算解耦",
+    leaves: "容量溢出与辅助损失",
+  },
+  {
+    id: "gshard",
+    label: "GShard",
+    kicker: "16 选 2",
+    experts: 16,
+    active: 2,
+    shared: 0,
+    devices: 8,
+    deviceLimit: 8,
+    latentRatio: 1,
+    capacity: 2,
+    balance: "aux",
+    summary: "Top-2 为每个 Token 组合两个专家，把 Transformer MoE 扩到数千设备。",
+    solves: "更强专家组合",
+    leaves: "两路计算与 All-to-All",
+  },
+  {
+    id: "mixtral",
+    label: "Mixtral",
+    kicker: "8 选 2",
+    experts: 8,
+    active: 2,
+    shared: 0,
+    devices: 8,
+    deviceLimit: 8,
+    latentRatio: 1,
+    capacity: 1.25,
+    balance: "aux",
+    summary: "少量大专家、每层 top-2；结构直观，成为开放生态理解和部署 MoE 的常用入口。",
+    solves: "开放可用性",
+    leaves: "粗专家可能学习重复知识",
+  },
+  {
+    id: "deepseek",
+    label: "DeepSeekMoE",
+    kicker: "1 shared + 63 选 7",
+    experts: 63,
+    active: 7,
+    shared: 1,
+    devices: 8,
+    deviceLimit: 8,
+    latentRatio: 1,
+    capacity: 1.25,
+    balance: "aux",
+    summary: "把专家切细并同时激活更多小专家；共享专家固定处理共性变换。",
+    solves: "专业化与知识冗余",
+    leaves: "细粒度提高通信扇出",
+  },
+  {
+    id: "v3",
+    label: "DeepSeek-V3",
+    kicker: "1 shared + 256 选 8",
+    experts: 256,
+    active: 8,
+    shared: 1,
+    devices: 8,
+    deviceLimit: 4,
+    latentRatio: 1,
+    capacity: 1,
+    balance: "lossfree",
+    summary: "Expert bias 只调 top-k 选择；node-limited routing 把每个 Token 限在最多四个节点。",
+    solves: "干扰梯度与跨节点扇出",
+    leaves: "固定步长 bias 会慢或振荡",
+  },
+  {
+    id: "latent",
+    label: "LatentMoE",
+    kicker: "512 选 24 · 4× latent",
+    experts: 512,
+    active: 24,
+    shared: 2,
+    devices: 8,
+    deviceLimit: 8,
+    latentRatio: 4,
+    capacity: 1.1,
+    balance: "lossfree",
+    summary: "先把 Token 从模型宽度投到 1/4 latent 宽度，再 dispatch 和执行 routed experts。",
+    solves: "权重带宽与通信载荷",
+    leaves: "投影开销与潜空间信息损失",
+  },
+  {
+    id: "k3",
+    label: "K3 Stable",
+    kicker: "2 shared + 896 选 16",
+    experts: 896,
+    active: 16,
+    shared: 2,
+    devices: 8,
+    deviceLimit: 8,
+    latentRatio: 2,
+    capacity: 1,
+    balance: "quantile",
+    summary: "半宽 latent routed path、两条全宽共享路径，并用 Quantile Balancing 面向极稀疏专家池。",
+    solves: "3T 级极稀疏与稳定均衡",
+    leaves: "需要 MoonEP 与专用内核协同",
+  },
+];
+
+const tokens = Array.from({ length: 12 }, (_, index) => index);
+const expertBins = Array.from({ length: 12 }, (_, index) => index);
+const routeLines = Array.from({ length: 36 }, (_, index) => ({
+  token: Math.floor(index / 3),
+  branch: index % 3,
+}));
+const loadBins = Array.from({ length: 32 }, (_, index) => index);
+const deviceCells = Array.from({ length: 64 }, (_, index) => ({
+  from: Math.floor(index / 8),
+  to: index % 8,
+}));
+---
+
+<section class="moe-lab" data-moe-lab>
+  <div class="lab-head">
+    <div>
+      <p class="lab-kicker">INTERACTIVE / MOE ROUTING LAB</p>
+      <h3>参数没有消失：只是每个 Token 选择不同路径</h3>
+    </div>
+    <p>
+      预设使用论文结构，负载与路由是确定性教学模拟。先切模型，再故意增加偏斜，观察“模型更稀疏”为何会把压力转移到均衡和通信。
+    </p>
+  </div>
+
+  <div class="preset-tabs" role="tablist" aria-label="选择 MoE 架构预设">
+    {presets.map((preset) => (
+      <button
+        type="button"
+        role="tab"
+        data-preset-button={preset.id}
+        aria-selected={preset.id === "switch" ? "true" : "false"}
+      >
+        <b>{preset.label}</b>
+        <span>{preset.kicker}</span>
+      </button>
+    ))}
+  </div>
+
+  <div class="lab-grid">
+    <div class="route-panel">
+      <div class="panel-label">
+        <span>01 / TOKEN → EXPERT</span>
+        <b data-route-title>SWITCH · 128 选 1</b>
+      </div>
+
+      <div class="route-map" aria-label="Token 路由到专家分组的简化示意">
+        <svg viewBox="0 0 620 360" preserveAspectRatio="none" aria-hidden="true">
+          {routeLines.map(({ token, branch }) => (
+            <path data-route-line data-token={token} data-branch={branch}></path>
+          ))}
+        </svg>
+        <div class="token-column">
+          <span>TOKENS</span>
+          {tokens.map((token) => <i data-token-dot={token}>t{token + 1}</i>)}
+        </div>
+        <div class="expert-column">
+          <span>EXPERT GROUPS</span>
+          {expertBins.map((bin) => (
+            <i data-expert-bin={bin}>
+              <b>E{bin + 1}</b>
+              <em><u data-expert-fill={bin}></u></em>
+              <small data-expert-load={bin}>0</small>
+            </i>
+          ))}
+        </div>
+      </div>
+
+      <div class="route-legend">
+        <span><i class="accepted"></i>被专家处理</span>
+        <span><i class="overflow"></i>超过 capacity</span>
+        <span><i class="shared"></i>共享专家另行固定执行</span>
+      </div>
+    </div>
+
+    <div class="story-panel">
+      {presets.map((preset) => (
+        <article data-preset-story={preset.id} hidden={preset.id !== "switch"}>
+          <span>{preset.kicker}</span>
+          <h3>{preset.label}</h3>
+          <p>{preset.summary}</p>
+          <dl>
+            <div><dt>主要解决</dt><dd>{preset.solves}</dd></div>
+            <div><dt>仍然留下</dt><dd>{preset.leaves}</dd></div>
+          </dl>
+        </article>
+      ))}
+      <div class="shared-readout">
+        <span>FIXED DENSE PATH</span>
+        <b data-shared-value>0 shared experts</b>
+        <p data-shared-note>Switch 没有固定共享专家；每个 Token 只走一个 routed expert。</p>
+      </div>
+    </div>
+  </div>
+
+  <div class="controls-panel">
+    <div class="controls-copy">
+      <p class="panel-kicker">02 / STRESS THE ROUTER</p>
+      <h3>把路由推向过热，再换一种均衡方法</h3>
+      <p>
+        模拟 512 个 Token。偏斜越高，越多 Token 争抢热门专家；capacity factor 越大，缓冲越多，但 padding、显存和通信预算也越大。
+      </p>
+    </div>
+
+    <div class="control-stack">
+      <label>
+        <span>路由偏斜 <output data-skew-output>70%</output></span>
+        <input data-skew type="range" min="0" max="100" value="70" step="5" />
+        <small>均匀 <i></i> 热门专家</small>
+      </label>
+      <label>
+        <span>Capacity factor <output data-capacity-output>1.25×</output></span>
+        <input data-capacity type="range" min="0.75" max="2" value="1.25" step="0.25" />
+        <small>紧容量 <i></i> 更多空槽</small>
+      </label>
+      <div class="balance-control">
+        <span>BALANCE MODE</span>
+        <div role="group" aria-label="负载均衡策略">
+          <button type="button" data-balance="none">无控制</button>
+          <button type="button" data-balance="aux" aria-pressed="true">Aux proxy</button>
+          <button type="button" data-balance="lossfree">Loss-Free</button>
+          <button type="button" data-balance="quantile">QB proxy</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div class="metric-grid">
+    <article>
+      <span>ROUTED SPARSITY</span>
+      <b data-active-fraction>1 / 128 · 0.78%</b>
+      <small data-active-note>不含 attention 与其他稠密路径</small>
+    </article>
+    <article>
+      <span>MAX / MEAN LOAD</span>
+      <b data-load-ratio>—</b>
+      <small>1.00× 才是完全均匀</small>
+    </article>
+    <article>
+      <span>OVERFLOW ROUTES</span>
+      <b data-drop-rate>—</b>
+      <small data-capacity-note>每专家容量 5 个 Token</small>
+    </article>
+    <article>
+      <span>DISPATCH + COMBINE</span>
+      <b data-comm-value>14.0 MiB</b>
+      <small data-comm-note>7168 维 BF16 教学载荷</small>
+    </article>
+    <article>
+      <span>DEVICE FANOUT</span>
+      <b data-fanout-value>—</b>
+      <small data-fanout-note>每 Token 平均触达设备数</small>
+    </article>
+    <article>
+      <span>COMBINATION SPACE</span>
+      <b data-combination-value>10²·¹</b>
+      <small>C(N,k) 上限，不代表已学会的技能数</small>
+    </article>
+  </div>
+
+  <div class="analysis-grid">
+    <div class="load-panel">
+      <div class="panel-label">
+        <span>03 / LOAD HISTOGRAM</span>
+        <b>32 个专家分组 · 红线是 capacity</b>
+      </div>
+      <div class="load-chart">
+        <div class="capacity-line" data-capacity-line><span>CAP</span></div>
+        {loadBins.map((bin) => (
+          <i data-load-bin={bin}><u></u><small>{String(bin + 1).padStart(2, "0")}</small></i>
+        ))}
+      </div>
+    </div>
+
+    <div class="device-panel">
+      <div class="panel-label">
+        <span>04 / ALL-TO-ALL</span>
+        <b data-device-title>8 个 EP ranks</b>
+      </div>
+      <div class="device-matrix" aria-label="设备间 dispatch 通信矩阵">
+        {deviceCells.map(({ from, to }) => (
+          <i data-device-cell data-from={from} data-to={to} title={`GPU ${from + 1} → GPU ${to + 1}`}></i>
+        ))}
+      </div>
+      <div class="device-axis">
+        <span>源设备 →</span>
+        <b>颜色越深，dispatch 的 Token 路由越多</b>
+      </div>
+    </div>
+  </div>
+
+  <div class="mechanism-strip">
+    <article><span>01</span><b>ROUTE</b><p>Router 为 Token 与专家打分，选 top-k。</p></article>
+    <i>→</i>
+    <article><span>02</span><b>DISPATCH</b><p>把 Token 搬到专家所在设备；第一次 All-to-All。</p></article>
+    <i>→</i>
+    <article><span>03</span><b>EXPERT</b><p>每个专家只处理收到的小批 Token。</p></article>
+    <i>→</i>
+    <article><span>04</span><b>COMBINE</b><p>结果搬回原设备，加权合并；第二次通信。</p></article>
+  </div>
+
+  <div class="lab-caveat">
+    <span>TEACHING SIMULATION, NOT A BENCHMARK</span>
+    <p>
+      Aux、Loss-Free 与 QB 在这里用确定性近似展示负载方向，不复现论文训练过程；通信值只计算 512 个 Token 的 BF16
+      dispatch/combine payload，不含协议、对齐、共享专家、梯度、索引与 kernel 开销。K3 还依赖 MoonEP 的冗余专家规划。
+    </p>
+  </div>
+
+  <script is:inline define:vars={{ presets }}>
+    const root = document.querySelector("[data-moe-lab]");
+    if (root) {
+      const presetButtons = [...root.querySelectorAll("[data-preset-button]")];
+      const stories = [...root.querySelectorAll("[data-preset-story]")];
+      const balanceButtons = [...root.querySelectorAll("[data-balance]")];
+      const skewInput = root.querySelector("[data-skew]");
+      const capacityInput = root.querySelector("[data-capacity]");
+      const virtualTokens = 512;
+      const hidden = 7168;
+      let activeId = "switch";
+      let balanceMode = "aux";
+
+      const presetFor = (id) => presets.find((preset) => preset.id === id) ?? presets[1];
+      const fract = (value) => value - Math.floor(value);
+      const noise = (token, expert) => fract(Math.sin((token + 1) * 12.9898 + (expert + 1) * 78.233) * 43758.5453);
+
+      const rawScore = (token, expert, config, skew) => {
+        if (config.experts === 1) return 1;
+        const domains = 8;
+        const tokenDomain = token % domains;
+        const expertDomain = expert % domains;
+        const domainAffinity = tokenDomain === expertDomain ? 1.25 : 0;
+        const hotExperts = Math.max(1, Math.floor(config.experts / 18));
+        const popularity = expert < hotExperts ? 1.1 - expert / hotExperts : 0;
+        const localTexture = noise(token, expert) * 1.15 + noise(expert, token) * 0.25;
+        return localTexture + skew * (domainAffinity + popularity);
+      };
+
+      const choose = (token, config, skew, biases, mode, currentLoads) => {
+        if (config.experts === 1) return [0];
+        const candidates = Array.from({ length: config.experts }, (_, expert) => ({
+          expert,
+          score: rawScore(token, expert, config, skew) + (biases[expert] ?? 0),
+        })).sort((a, b) => b.score - a.score);
+
+        let allowedDevices = null;
+        if (config.deviceLimit < config.devices) {
+          const deviceScores = Array.from({ length: config.devices }, (_, device) => ({
+            device,
+            score: candidates.find((candidate) => candidate.expert % config.devices === device)?.score ?? -Infinity,
+          })).sort((a, b) => b.score - a.score);
+          allowedDevices = new Set(deviceScores.slice(0, config.deviceLimit).map((entry) => entry.device));
+        }
+
+        const filtered = allowedDevices
+          ? candidates.filter((candidate) => allowedDevices.has(candidate.expert % config.devices))
+          : candidates;
+
+        if (mode === "quantile") {
+          const pool = filtered.slice(0, Math.min(filtered.length, Math.max(config.active * 5, 32)));
+          return pool
+            .sort((a, b) => {
+              const aPressure = (currentLoads[a.expert] ?? 0) - a.score * 0.35;
+              const bPressure = (currentLoads[b.expert] ?? 0) - b.score * 0.35;
+              return aPressure - bPressure;
+            })
+            .slice(0, config.active)
+            .map((candidate) => candidate.expert);
+        }
+        return filtered.slice(0, config.active).map((candidate) => candidate.expert);
+      };
+
+      const routeBatch = (config, skew, mode, biases = new Float64Array(config.experts)) => {
+        const loads = new Uint32Array(config.experts);
+        const assignments = [];
+        for (let token = 0; token < virtualTokens; token += 1) {
+          const selected = choose(token, config, skew, biases, mode, loads);
+          assignments.push(selected);
+          selected.forEach((expert) => { loads[expert] += 1; });
+        }
+        return { loads, assignments };
+      };
+
+      const simulate = (config, skew, mode, capacityFactor) => {
+        const biases = new Float64Array(config.experts);
+        if (mode === "aux" || mode === "lossfree") {
+          const iterations = mode === "aux" ? 2 : 5;
+          const rate = mode === "aux" ? 0.18 : 0.34;
+          for (let iteration = 0; iteration < iterations; iteration += 1) {
+            const trial = routeBatch(config, skew, "none", biases);
+            const mean = virtualTokens * config.active / config.experts;
+            trial.loads.forEach((load, expert) => {
+              biases[expert] += rate * (mean - load) / Math.max(1, mean);
+            });
+          }
+        }
+
+        const routed = routeBatch(config, skew, mode, biases);
+        const mean = virtualTokens * config.active / config.experts;
+        const capacity = Math.max(1, Math.ceil(mean * capacityFactor));
+        let overflow = 0;
+        routed.loads.forEach((load) => { overflow += Math.max(0, load - capacity); });
+        return { ...routed, mean, capacity, overflow };
+      };
+
+      const logCombination = (n, k) => {
+        if (k <= 0 || n <= 1) return 0;
+        const compactK = Math.min(k, n - k);
+        let result = 0;
+        for (let index = 1; index <= compactK; index += 1) {
+          result += Math.log10(n - compactK + index) - Math.log10(index);
+        }
+        return result;
+      };
+
+      const formatBytes = (bytes) => {
+        const mib = bytes / 1024 / 1024;
+        return mib >= 1024 ? `${(mib / 1024).toFixed(2)} GiB` : `${mib.toFixed(1)} MiB`;
+      };
+
+      const updateRouteMap = (config, simulation) => {
+        const binLoads = new Array(12).fill(0);
+        simulation.loads.forEach((load, expert) => {
+          const bin = Math.min(11, Math.floor(expert / config.experts * 12));
+          binLoads[bin] += load;
+        });
+        const maxBin = Math.max(1, ...binLoads);
+        binLoads.forEach((load, bin) => {
+          const fill = root.querySelector(`[data-expert-fill="${bin}"]`);
+          const value = root.querySelector(`[data-expert-load="${bin}"]`);
+          if (fill) fill.style.width = `${Math.max(2, load / maxBin * 100)}%`;
+          if (value) value.textContent = String(load);
+        });
+
+        const routeLines = [...root.querySelectorAll("[data-route-line]")];
+        routeLines.forEach((line) => {
+          const token = Number(line.dataset.token);
+          const branch = Number(line.dataset.branch);
+          const selected = simulation.assignments[token] ?? [];
+          const expert = selected[branch % Math.max(1, selected.length)] ?? 0;
+          const expertBin = Math.min(11, Math.floor(expert / config.experts * 12));
+          const startY = 38 + token * 25.8;
+          const endY = 38 + expertBin * 25.8;
+          line.setAttribute("d", `M 72 ${startY} C 220 ${startY}, 392 ${endY}, 548 ${endY}`);
+          line.toggleAttribute("data-visible", branch < Math.min(3, config.active));
+          const over = simulation.loads[expert] > simulation.capacity;
+          line.toggleAttribute("data-overflow", over);
+        });
+      };
+
+      const updateLoadChart = (config, simulation) => {
+        const bins = new Array(32).fill(0);
+        const counts = new Array(32).fill(0);
+        simulation.loads.forEach((load, expert) => {
+          const bin = Math.min(31, Math.floor(expert / config.experts * 32));
+          bins[bin] += load;
+          counts[bin] += 1;
+        });
+        const averages = bins.map((load, index) => load / Math.max(1, counts[index]));
+        const max = Math.max(simulation.capacity, ...averages, 1);
+        root.querySelector("[data-capacity-line]").style.bottom = `${simulation.capacity / max * 82}%`;
+        averages.forEach((load, index) => {
+          const bar = root.querySelector(`[data-load-bin="${index}"] u`);
+          if (bar) {
+            bar.style.height = `${Math.max(2, load / max * 100)}%`;
+            bar.toggleAttribute("data-over", load > simulation.capacity);
+          }
+        });
+      };
+
+      const updateDeviceMatrix = (config, simulation) => {
+        const matrix = Array.from({ length: 8 }, () => new Uint32Array(8));
+        if (config.devices > 1) {
+          simulation.assignments.forEach((experts, token) => {
+            const source = token % config.devices;
+            experts.forEach((expert) => {
+              const target = expert % config.devices;
+              matrix[source][target] += 1;
+            });
+          });
+        }
+        const max = Math.max(1, ...matrix.flatMap((row) => [...row]));
+        root.querySelectorAll("[data-device-cell]").forEach((cell) => {
+          const from = Number(cell.dataset.from);
+          const to = Number(cell.dataset.to);
+          const active = from < config.devices && to < config.devices;
+          const value = active ? matrix[from][to] : 0;
+          cell.style.opacity = active ? String(0.08 + value / max * 0.92) : "0.025";
+          cell.toggleAttribute("data-local", active && from === to);
+        });
+        root.querySelector("[data-device-title]").textContent =
+          config.devices === 1 ? "稠密本地执行 · 无 EP 通信" : `${config.devices} 个 EP ranks`;
+      };
+
+      const updateMetrics = (config, simulation, capacityFactor) => {
+        const maxLoad = Math.max(...simulation.loads);
+        const loadRatio = maxLoad / Math.max(simulation.mean, 1);
+        const dropRate = simulation.overflow / Math.max(1, virtualTokens * config.active);
+        const routedFraction = config.active / config.experts * 100;
+        const payloadBytes = config.devices === 1
+          ? 0
+          : virtualTokens * config.active * hidden * 2 * 2 / config.latentRatio;
+        const fanout = config.devices === 1
+          ? 0
+          : simulation.assignments.reduce((sum, experts) => {
+              return sum + new Set(experts.map((expert) => expert % config.devices)).size;
+            }, 0) / virtualTokens;
+        const combinations = logCombination(config.experts, config.active);
+
+        root.querySelector("[data-active-fraction]").textContent =
+          `${config.active} / ${config.experts} · ${routedFraction < 10 ? routedFraction.toFixed(2) : routedFraction.toFixed(1)}%`;
+        root.querySelector("[data-active-note]").textContent =
+          config.shared > 0
+            ? `另有 ${config.shared} 个共享专家；不含 attention 等稠密路径`
+            : "不含 attention 与其他稠密路径";
+        root.querySelector("[data-load-ratio]").textContent = `${loadRatio.toFixed(2)}×`;
+        root.querySelector("[data-drop-rate]").textContent = `${(dropRate * 100).toFixed(1)}%`;
+        root.querySelector("[data-capacity-note]").textContent =
+          `每专家容量 ${simulation.capacity}；CF ${capacityFactor.toFixed(2)}×`;
+        root.querySelector("[data-comm-value]").textContent = payloadBytes === 0 ? "0 · LOCAL" : formatBytes(payloadBytes);
+        root.querySelector("[data-comm-note]").textContent =
+          config.latentRatio > 1
+            ? `${config.latentRatio}× latent 压缩后的 BF16 教学载荷`
+            : "7168 维 BF16 教学载荷";
+        root.querySelector("[data-fanout-value]").textContent = config.devices === 1 ? "1.00×" : `${fanout.toFixed(2)} devices`;
+        root.querySelector("[data-fanout-note]").textContent =
+          config.deviceLimit < config.devices
+            ? `每 Token 最多 ${config.deviceLimit} 个设备/节点`
+            : "每 Token 平均触达设备数";
+        root.querySelector("[data-combination-value]").textContent =
+          combinations < 6 ? `${Math.round(10 ** combinations).toLocaleString("zh-CN")} 种` : `10^${combinations.toFixed(1)}`;
+      };
+
+      const update = () => {
+        const config = presetFor(activeId);
+        const skew = Number(skewInput.value) / 100;
+        const capacityFactor = Number(capacityInput.value);
+        const simulation = simulate(config, skew, balanceMode, capacityFactor);
+        root.querySelector("[data-skew-output]").textContent = `${Math.round(skew * 100)}%`;
+        root.querySelector("[data-capacity-output]").textContent = `${capacityFactor.toFixed(2)}×`;
+        root.querySelector("[data-route-title]").textContent =
+          `${config.label.toUpperCase()} · ${config.experts} 选 ${config.active}`;
+        root.querySelector("[data-shared-value]").textContent = `${config.shared} shared expert${config.shared === 1 ? "" : "s"}`;
+        root.querySelector("[data-shared-note]").textContent =
+          config.shared > 0
+            ? `这些全宽专家不参与 top-k；每个 Token 都固定经过 ${config.shared} 条共享路径。`
+            : `${config.label} 没有固定共享专家；所有专家路径由 router 决定。`;
+        updateRouteMap(config, simulation);
+        updateLoadChart(config, simulation);
+        updateDeviceMatrix(config, simulation);
+        updateMetrics(config, simulation, capacityFactor);
+      };
+
+      const selectPreset = (id) => {
+        const config = presetFor(id);
+        activeId = id;
+        balanceMode = config.balance;
+        capacityInput.value = String(config.capacity);
+        presetButtons.forEach((button) => {
+          button.setAttribute("aria-selected", String(button.dataset.presetButton === id));
+        });
+        stories.forEach((story) => { story.hidden = story.dataset.presetStory !== id; });
+        balanceButtons.forEach((button) => {
+          button.setAttribute("aria-pressed", String(button.dataset.balance === balanceMode));
+        });
+        update();
+      };
+
+      presetButtons.forEach((button) => {
+        button.addEventListener("click", () => selectPreset(button.dataset.presetButton));
+      });
+      balanceButtons.forEach((button) => {
+        button.addEventListener("click", () => {
+          balanceMode = button.dataset.balance;
+          balanceButtons.forEach((item) => {
+            item.setAttribute("aria-pressed", String(item.dataset.balance === balanceMode));
+          });
+          update();
+        });
+      });
+      skewInput.addEventListener("input", update);
+      capacityInput.addEventListener("input", update);
+      selectPreset(activeId);
+    }
+  </script>
+</section>
+
+<style>
+  .moe-lab {
+    margin-block: 56px;
+    border: 1px solid var(--line-strong);
+    background: var(--paper-raised);
+  }
+
+  .lab-head,
+  .controls-panel {
+    display: grid;
+    grid-template-columns: 1.2fr 0.8fr;
+    gap: 56px;
+    align-items: end;
+    padding: clamp(28px, 4vw, 52px);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .lab-kicker,
+  .panel-kicker {
+    margin: 0 0 16px;
+    color: var(--copper);
+    font: 0.64rem/1 var(--mono);
+    letter-spacing: 0.13em;
+  }
+
+  .lab-head h3,
+  .controls-copy h3 {
+    max-width: 720px;
+    margin: 0;
+    font-size: clamp(1.8rem, 3vw, 3.2rem);
+    line-height: 1.06;
+  }
+
+  .lab-head > p,
+  .controls-copy > p:last-child {
+    margin: 0;
+    color: var(--ink-soft);
+    line-height: 1.8;
+  }
+
+  .preset-tabs {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    border-bottom: 1px solid var(--line);
+  }
+
+  .preset-tabs button {
+    min-height: 80px;
+    padding: 15px 16px;
+    border: 0;
+    border-right: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+    color: var(--ink-soft);
+    background: transparent;
+    text-align: left;
+    cursor: pointer;
+  }
+
+  .preset-tabs button:nth-child(4n) {
+    border-right: 0;
+  }
+
+  .preset-tabs button:nth-child(n + 5) {
+    border-bottom: 0;
+  }
+
+  .preset-tabs button:hover,
+  .preset-tabs button[aria-selected="true"] {
+    color: var(--paper);
+    background: var(--navy);
+  }
+
+  .preset-tabs b,
+  .preset-tabs span {
+    display: block;
+  }
+
+  .preset-tabs b {
+    font-size: 0.84rem;
+  }
+
+  .preset-tabs span {
+    margin-top: 9px;
+    font: 0.56rem/1.25 var(--mono);
+  }
+
+  .lab-grid,
+  .analysis-grid {
+    display: grid;
+    grid-template-columns: minmax(0, 1.5fr) minmax(260px, 0.5fr);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .route-panel,
+  .load-panel {
+    padding: clamp(24px, 3vw, 40px);
+    border-right: 1px solid var(--line);
+  }
+
+  .panel-label {
+    display: flex;
+    justify-content: space-between;
+    gap: 18px;
+    margin-bottom: 24px;
+  }
+
+  .panel-label span {
+    color: var(--ink-muted);
+    font: 0.6rem/1.4 var(--mono);
+    letter-spacing: 0.1em;
+  }
+
+  .panel-label b {
+    color: var(--ink-soft);
+    font: 0.66rem/1.4 var(--mono);
+    text-align: right;
+  }
+
+  .route-map {
+    position: relative;
+    min-height: 360px;
+    border: 1px solid var(--line);
+    background:
+      linear-gradient(90deg, rgba(37, 55, 77, 0.025) 1px, transparent 1px) 0 0 / 32px 32px,
+      var(--paper);
+    overflow: hidden;
+  }
+
+  .route-map svg {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+  }
+
+  .route-map path {
+    fill: none;
+    stroke: var(--sage);
+    stroke-width: 1.5;
+    opacity: 0;
+  }
+
+  .route-map path[data-visible] {
+    opacity: 0.55;
+  }
+
+  .route-map path[data-overflow] {
+    stroke: var(--copper);
+    stroke-dasharray: 5 4;
+    opacity: 0.75;
+  }
+
+  .token-column,
+  .expert-column {
+    position: absolute;
+    inset-block: 18px;
+    display: grid;
+    grid-template-rows: 18px repeat(12, 1fr);
+    align-items: center;
+  }
+
+  .token-column {
+    left: 18px;
+    width: 58px;
+  }
+
+  .expert-column {
+    right: 18px;
+    width: 164px;
+  }
+
+  .token-column > span,
+  .expert-column > span {
+    color: var(--ink-muted);
+    font: 0.52rem/1 var(--mono);
+    letter-spacing: 0.1em;
+  }
+
+  .token-column i {
+    display: grid;
+    place-items: center;
+    width: 30px;
+    height: 20px;
+    border: 1px solid var(--line-strong);
+    color: var(--ink-soft);
+    background: var(--paper-raised);
+    font: normal 0.56rem/1 var(--mono);
+  }
+
+  .expert-column i {
+    display: grid;
+    grid-template-columns: 28px 1fr 30px;
+    gap: 8px;
+    align-items: center;
+    font-style: normal;
+  }
+
+  .expert-column b,
+  .expert-column small {
+    font: 0.52rem/1 var(--mono);
+  }
+
+  .expert-column small {
+    color: var(--ink-muted);
+    text-align: right;
+  }
+
+  .expert-column em {
+    height: 5px;
+    background: var(--paper-shadow);
+  }
+
+  .expert-column u {
+    display: block;
+    width: 2%;
+    height: 100%;
+    background: var(--sage);
+    transition: width 180ms ease;
+  }
+
+  .route-legend {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 20px;
+    margin-top: 16px;
+  }
+
+  .route-legend span {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+    color: var(--ink-muted);
+    font: 0.58rem/1.4 var(--mono);
+  }
+
+  .route-legend i {
+    width: 22px;
+    border-top: 2px solid var(--sage);
+  }
+
+  .route-legend i.overflow {
+    border-color: var(--copper);
+    border-top-style: dashed;
+  }
+
+  .route-legend i.shared {
+    border-width: 5px;
+    border-color: var(--navy);
+  }
+
+  .story-panel {
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
+    background: var(--paper-shadow);
+  }
+
+  .story-panel article,
+  .shared-readout {
+    padding: clamp(26px, 3vw, 42px);
+  }
+
+  .story-panel article > span,
+  .shared-readout > span {
+    color: var(--copper);
+    font: 0.6rem/1 var(--mono);
+    letter-spacing: 0.09em;
+  }
+
+  .story-panel h3 {
+    margin: 22px 0 16px;
+    font-family: var(--serif);
+    font-size: 2.1rem;
+  }
+
+  .story-panel p {
+    color: var(--ink-soft);
+    line-height: 1.75;
+  }
+
+  .story-panel dl {
+    margin-top: 26px;
+  }
+
+  .story-panel dl div {
+    padding: 14px 0;
+    border-top: 1px solid var(--line);
+  }
+
+  .story-panel dt {
+    color: var(--ink-muted);
+    font: 0.56rem/1 var(--mono);
+  }
+
+  .story-panel dd {
+    margin: 8px 0 0;
+    font-size: 0.85rem;
+  }
+
+  .shared-readout {
+    border-top: 1px solid var(--line);
+    background: var(--paper-raised);
+  }
+
+  .shared-readout b {
+    display: block;
+    margin-top: 14px;
+    font-family: var(--mono);
+    font-size: 0.82rem;
+  }
+
+  .shared-readout p {
+    margin-bottom: 0;
+    font-size: 0.82rem;
+  }
+
+  .controls-panel {
+    align-items: start;
+  }
+
+  .control-stack {
+    display: grid;
+    gap: 24px;
+  }
+
+  .control-stack label > span,
+  .balance-control > span {
+    display: flex;
+    justify-content: space-between;
+    color: var(--ink-soft);
+    font: 0.66rem/1 var(--mono);
+  }
+
+  .control-stack output {
+    color: var(--copper);
+  }
+
+  .control-stack input {
+    width: 100%;
+    margin: 15px 0 9px;
+    accent-color: var(--copper);
+  }
+
+  .control-stack label > small {
+    display: flex;
+    justify-content: space-between;
+    color: var(--ink-muted);
+    font: 0.54rem/1 var(--mono);
+  }
+
+  .control-stack label > small i {
+    flex: 1;
+    margin: 4px 10px 0;
+    border-top: 1px dotted var(--line-strong);
+  }
+
+  .balance-control > div {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    margin-top: 12px;
+  }
+
+  .balance-control button {
+    min-height: 38px;
+    border: 1px solid var(--line);
+    color: var(--ink-soft);
+    background: transparent;
+    font: 0.58rem/1 var(--mono);
+    cursor: pointer;
+  }
+
+  .balance-control button[aria-pressed="true"] {
+    border-color: var(--navy);
+    color: var(--paper);
+    background: var(--navy);
+  }
+
+  .metric-grid {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    border-bottom: 1px solid var(--line);
+  }
+
+  .metric-grid article {
+    min-height: 142px;
+    padding: 24px;
+    border-right: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .metric-grid article:nth-child(3n) {
+    border-right: 0;
+  }
+
+  .metric-grid article:nth-child(n + 4) {
+    border-bottom: 0;
+  }
+
+  .metric-grid span,
+  .metric-grid small {
+    display: block;
+    color: var(--ink-muted);
+    font: 0.56rem/1.4 var(--mono);
+    letter-spacing: 0.07em;
+  }
+
+  .metric-grid b {
+    display: block;
+    margin: 19px 0 12px;
+    font-family: var(--mono);
+    font-size: clamp(1.15rem, 2vw, 1.65rem);
+  }
+
+  .analysis-grid {
+    grid-template-columns: minmax(0, 1.25fr) minmax(280px, 0.75fr);
+  }
+
+  .load-chart {
+    position: relative;
+    display: grid;
+    grid-template-columns: repeat(32, minmax(3px, 1fr));
+    gap: 3px;
+    align-items: end;
+    height: 270px;
+    padding: 16px 8px 24px;
+    border-left: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .load-chart > i {
+    position: relative;
+    height: 100%;
+  }
+
+  .load-chart u {
+    position: absolute;
+    inset: auto 0 0;
+    height: 2%;
+    background: var(--sage);
+    text-decoration: none;
+    transition: height 180ms ease;
+  }
+
+  .load-chart u[data-over] {
+    background: var(--copper);
+  }
+
+  .load-chart small {
+    position: absolute;
+    left: 50%;
+    bottom: -20px;
+    color: var(--ink-muted);
+    font: 0.42rem/1 var(--mono);
+    transform: translateX(-50%) rotate(-90deg);
+  }
+
+  .capacity-line {
+    position: absolute;
+    z-index: 2;
+    right: 0;
+    left: 0;
+    bottom: 50%;
+    border-top: 1px dashed var(--copper);
+    pointer-events: none;
+  }
+
+  .capacity-line span {
+    position: absolute;
+    right: 0;
+    bottom: 4px;
+    color: var(--copper);
+    font: 0.48rem/1 var(--mono);
+  }
+
+  .device-panel {
+    padding: clamp(24px, 3vw, 40px);
+  }
+
+  .device-matrix {
+    display: grid;
+    grid-template-columns: repeat(8, 1fr);
+    gap: 4px;
+    aspect-ratio: 1;
+    max-width: 340px;
+    margin: 24px auto;
+    padding: 10px;
+    border: 1px solid var(--line);
+    background: var(--paper);
+  }
+
+  .device-matrix i {
+    background: var(--copper);
+    transition: opacity 180ms ease;
+  }
+
+  .device-matrix i[data-local] {
+    background: var(--navy);
+  }
+
+  .device-axis {
+    display: flex;
+    justify-content: space-between;
+    gap: 12px;
+    color: var(--ink-muted);
+    font: 0.54rem/1.5 var(--mono);
+  }
+
+  .mechanism-strip {
+    display: grid;
+    grid-template-columns: 1fr auto 1fr auto 1fr auto 1fr;
+    align-items: stretch;
+    border-bottom: 1px solid var(--line);
+  }
+
+  .mechanism-strip article {
+    padding: 26px;
+  }
+
+  .mechanism-strip article > span {
+    color: var(--copper);
+    font: 0.58rem/1 var(--mono);
+  }
+
+  .mechanism-strip article > b {
+    display: block;
+    margin-top: 12px;
+    font: 0.72rem/1 var(--mono);
+    letter-spacing: 0.08em;
+  }
+
+  .mechanism-strip p {
+    margin-bottom: 0;
+    color: var(--ink-soft);
+    font-size: 0.82rem;
+    line-height: 1.65;
+  }
+
+  .mechanism-strip > i {
+    display: grid;
+    place-items: center;
+    color: var(--copper);
+    font-style: normal;
+  }
+
+  .lab-caveat {
+    display: grid;
+    grid-template-columns: 230px 1fr;
+    gap: 32px;
+    padding: 24px clamp(28px, 4vw, 52px);
+    background: var(--navy);
+    color: var(--paper);
+  }
+
+  .lab-caveat span {
+    color: var(--copper-light);
+    font: 0.6rem/1.5 var(--mono);
+    letter-spacing: 0.08em;
+  }
+
+  .lab-caveat p {
+    margin: 0;
+    color: rgba(245, 242, 234, 0.78);
+    font-size: 0.8rem;
+    line-height: 1.65;
+  }
+
+  @media (max-width: 900px) {
+    .lab-head,
+    .controls-panel,
+    .lab-grid,
+    .analysis-grid {
+      grid-template-columns: 1fr;
+    }
+
+    .lab-head {
+      gap: 24px;
+    }
+
+    .route-panel,
+    .load-panel {
+      border-right: 0;
+      border-bottom: 1px solid var(--line);
+    }
+
+    .metric-grid {
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+    }
+
+    .metric-grid article:nth-child(n) {
+      border-right: 1px solid var(--line);
+      border-bottom: 1px solid var(--line);
+    }
+
+    .metric-grid article:nth-child(2n) {
+      border-right: 0;
+    }
+
+    .metric-grid article:nth-child(n + 5) {
+      border-bottom: 0;
+    }
+
+    .mechanism-strip {
+      grid-template-columns: 1fr 1fr;
+    }
+
+    .mechanism-strip > i {
+      display: none;
+    }
+  }
+
+  @media (max-width: 600px) {
+    .preset-tabs {
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+    }
+
+    .preset-tabs button:nth-child(n) {
+      border-right: 1px solid var(--line);
+      border-bottom: 1px solid var(--line);
+    }
+
+    .preset-tabs button:nth-child(2n) {
+      border-right: 0;
+    }
+
+    .preset-tabs button:nth-child(n + 7) {
+      border-bottom: 0;
+    }
+
+    .route-map {
+      min-height: 330px;
+    }
+
+    .expert-column {
+      width: 116px;
+    }
+
+    .expert-column i {
+      grid-template-columns: 24px 1fr;
+    }
+
+    .expert-column small {
+      display: none;
+    }
+
+    .metric-grid {
+      grid-template-columns: 1fr;
+    }
+
+    .metric-grid article:nth-child(n) {
+      border-right: 0;
+      border-bottom: 1px solid var(--line);
+    }
+
+    .metric-grid article:last-child {
+      border-bottom: 0;
+    }
+
+    .load-chart {
+      gap: 2px;
+      height: 220px;
+    }
+
+    .load-chart small {
+      display: none;
+    }
+
+    .mechanism-strip {
+      grid-template-columns: 1fr;
+    }
+
+    .mechanism-strip article {
+      border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+    }
+
+    .lab-caveat {
+      grid-template-columns: 1fr;
+      gap: 12px;
+    }
+  }
+</style>
diff --git a/src/components/SiteFooter.astro b/src/components/SiteFooter.astro
index 62b7b12..92c2ccc 100644
--- a/src/components/SiteFooter.astro
+++ b/src/components/SiteFooter.astro
@@ -5,6 +5,7 @@
   </div>
   <div class="footer-links">
     <a href="/roadmap/">学习地图</a>
+    <a href="/moe/">MoE 专题</a>
     <a href="/long-context/">长上下文专题</a>
     <a href="/progress/">研究进度</a>
     <a href="https://git.k1412.top/wuyang/llm-atlas" rel="noreferrer">开放源码</a>
diff --git a/src/components/SiteHeader.astro b/src/components/SiteHeader.astro
index b2c97dc..956d88b 100644
--- a/src/components/SiteHeader.astro
+++ b/src/components/SiteHeader.astro
@@ -10,6 +10,7 @@ const items = [
   { id: "k3", href: "/k3/", label: "K3 解剖" },
   { id: "deepseek", href: "/deepseek/", label: "DeepSeek" },
   { id: "foundations", href: "/foundations/", label: "基础原理" },
+  { id: "moe", href: "/moe/", label: "MoE" },
   { id: "long-context", href: "/long-context/", label: "长上下文" },
   { id: "papers", href: "/papers/", label: "论文库" },
   { id: "progress", href: "/progress/", label: "进度" },
diff --git a/src/data/chapters.ts b/src/data/chapters.ts
index 555a061..4388540 100644
--- a/src/data/chapters.ts
+++ b/src/data/chapters.ts
@@ -95,14 +95,14 @@ export const chapters: Chapter[] = [
   },
   {
     number: "06",
-    slug: "architecture/moe",
+    slug: "moe",
     title: "稀疏计算与 MoE",
     kicker: "SPARSE EXPERTS",
     question: "怎样让模型装下更多知识，却不让每个 Token 都付全部算力？",
     summary: "从条件计算到 DeepSeekMoE、LatentMoE 与 K3 Stable LatentMoE，解释路由、特化和负载均衡。",
-    status: "researching",
-    progress: 28,
-    papers: 17,
+    status: "published",
+    progress: 74,
+    papers: 19,
     prerequisites: ["02", "04"],
     highlights: ["专家路由", "细粒度专家", "896 选 16"],
   },
diff --git a/src/data/papers.ts b/src/data/papers.ts
index 05f8a0a..57ea561 100644
--- a/src/data/papers.ts
+++ b/src/data/papers.ts
@@ -71,6 +71,14 @@ export const papers: Paper[] = [
     contribution: "把 BPE 引入神经机器翻译，形成现代子词分词主线。",
     verified: true,
   },
+  {
+    year: 1991,
+    title: "Adaptive Mixtures of Local Experts",
+    url: "https://doi.org/10.1162/neco.1991.3.1.79",
+    topics: ["MoE"],
+    contribution: "以门控网络让多个局部专家竞争分工，是现代 MoE 的概念起点。",
+    verified: true,
+  },
   {
     year: 2017,
     title: "Attention Is All You Need",
@@ -401,6 +409,22 @@ export const papers: Paper[] = [
     contribution: "系统化稀疏专家的稳定训练与迁移配方。",
     verified: true,
   },
+  {
+    year: 2022,
+    title: "Mixture-of-Experts with Expert Choice Routing",
+    url: "https://arxiv.org/abs/2202.09368",
+    topics: ["MoE"],
+    contribution: "把 token 选专家反转为专家选固定容量的 token，直接控制专家负载。",
+    verified: true,
+  },
+  {
+    year: 2023,
+    title: "From Sparse to Soft Mixtures of Experts",
+    url: "https://arxiv.org/abs/2308.00951",
+    topics: ["MoE"],
+    contribution: "用连续 slot 分配替代硬 top-k，探索完全可微的专家混合。",
+    verified: true,
+  },
   {
     year: 2024,
     title: "Mixtral of Experts",
@@ -427,6 +451,23 @@ export const papers: Paper[] = [
     spotlight: "DeepSeek",
     verified: true,
   },
+  {
+    year: 2024,
+    title: "Mixture-of-Depths: Dynamically Allocating Compute in Transformer-Based Language Models",
+    url: "https://arxiv.org/abs/2404.02258",
+    topics: ["MoE", "Transformer"],
+    contribution: "把条件计算从专家宽度扩到网络深度，让不同 Token 动态跳过或进入层。",
+    verified: true,
+  },
+  {
+    year: 2024,
+    title: "Auxiliary-Loss-Free Load Balancing Strategy for Mixture-of-Experts",
+    url: "https://arxiv.org/abs/2408.15664",
+    topics: ["MoE"],
+    contribution: "以只影响 top-k 选择的 expert bias 调负载，避免均衡辅助损失干扰主梯度。",
+    spotlight: "DeepSeek",
+    verified: true,
+  },
   {
     year: 2024,
     title: "DeepSeek-V3 Technical Report",
diff --git a/src/pages/deepseek/index.astro b/src/pages/deepseek/index.astro
index 8314a8d..2837024 100644
--- a/src/pages/deepseek/index.astro
+++ b/src/pages/deepseek/index.astro
@@ -140,6 +140,7 @@ const toc = [
             因此模型侧路由与系统侧 Expert Parallel 从来不能分开看。
           </p>
         </div>
+        <a class="button primary" href="/moe/#deepseek">进入 MoE 专题：比较粗专家、细粒度专家与共享专家 →</a>
       </section>
 
       <section class="article-section" id="mla">
@@ -212,6 +213,10 @@ const toc = [
           根据近期负载上调冷门专家、下调热门专家；bias 只影响路由选择，不直接进入最终门控权重，
           从而把“系统要均衡”和“模型要准确”更松地解耦。
         </p>
+        <p>
+          <a href="/moe/#balance">专题版推导</a>会进一步区分 z-loss、辅助平衡损失、Loss-Free expert bias
+          与 K3 Quantile Balancing；“aux-loss-free”并不等于系统里不存在任何平衡约束。
+        </p>
 
         <h3>FP8 训练真正难在哪</h3>
         <p>
diff --git a/src/pages/index.astro b/src/pages/index.astro
index 0cb66ae..af20342 100644
--- a/src/pages/index.astro
+++ b/src/pages/index.astro
@@ -7,6 +7,7 @@ import { chapters, statusLabel } from "@/data/chapters";
 const routes: Record<string, string> = {
   roadmap: "/roadmap/",
   foundations: "/foundations/",
+  moe: "/moe/",
   "long-context": "/long-context/",
 };
 
@@ -75,6 +76,7 @@ const paths = [
           <a class="button primary" href="/roadmap/">选择学习路径 <span aria-hidden="true">↓</span></a>
           <a class="button" href="/k3/">直接解剖 K3</a>
           <a class="button" href="/deepseek/">DeepSeek 专题</a>
+          <a class="button" href="/moe/">MoE 专题</a>
           <a class="button" href="/long-context/">长上下文专题</a>
         </div>
       </div>
@@ -85,7 +87,7 @@ const paths = [
         <div class="hero-stats">
           <div><b>16</b><span>核心专题</span></div>
           <div><b>151</b><span>K3 报告来源</span></div>
-          <div><b>125</b><span>关键论文索引</span></div>
+          <div><b>130</b><span>关键论文索引</span></div>
           <div><b>47p</b><span>K3 技术报告</span></div>
         </div>
       </aside>
@@ -97,23 +99,41 @@ const paths = [
     </div>
   </section>
 
-  <section class="section compact release-section" id="new-long-context">
-    <a class="release-card" href="/long-context/">
-      <div>
-        <p class="eyebrow"><span>NEW / CHAPTER 07</span> LONG CONTEXT</p>
-        <h2>一百万 Token，不是一扇更大的窗</h2>
-        <p>
-          新专题把长上下文拆成计算、缓存、位置、状态容量与系统五张账单，
-          沿 26 篇一手论文走完 FlashAttention、MLA、Delta Rule、KDA、Kimi K3 与 DeepSeek-V4。
-        </p>
-      </div>
-      <dl>
-        <div><dt>LINEAGE</dt><dd>2019 → 2026</dd></div>
-        <div><dt>VISUALS</dt><dd>10+ 机制图</dd></div>
-        <div><dt>LAB</dt><dd>8 种策略 · 4 档长度</dd></div>
-      </dl>
-      <span class="release-arrow" aria-hidden="true">进入专题 →</span>
-    </a>
+  <section class="section compact release-section" id="new-chapters">
+    <div class="release-grid">
+      <a class="release-card moe-release" href="/moe/">
+        <div>
+          <p class="eyebrow"><span>NEW / CHAPTER 06</span> SPARSE EXPERTS</p>
+          <h2>2.8T 参数，不等于每个 Token 跑 2.8T</h2>
+          <p>
+            把 MoE 拆成容量、激活计算、路由、负载、通信与稳定性六张账，
+            从 Switch、DeepSeekMoE、Loss-Free、LatentMoE 一路走到 K3 Stable LatentMoE。
+          </p>
+        </div>
+        <dl>
+          <div><dt>LINEAGE</dt><dd>1991 → 2026</dd></div>
+          <div><dt>PAPERS</dt><dd>19 篇一手来源</dd></div>
+          <div><dt>LAB</dt><dd>8 架构 · 4 平衡策略</dd></div>
+        </dl>
+        <span class="release-arrow" aria-hidden="true">进入 MoE 专题 →</span>
+      </a>
+      <a class="release-card context-release" href="/long-context/">
+        <div>
+          <p class="eyebrow"><span>CHAPTER 07</span> LONG CONTEXT</p>
+          <h2>一百万 Token，不是一扇更大的窗</h2>
+          <p>
+            把长上下文拆成计算、缓存、位置、状态容量与系统五张账，
+            沿 26 篇一手论文走完 FlashAttention、MLA、Delta Rule、KDA、Kimi K3 与 DeepSeek-V4。
+          </p>
+        </div>
+        <dl>
+          <div><dt>LINEAGE</dt><dd>2019 → 2026</dd></div>
+          <div><dt>VISUALS</dt><dd>10+ 机制图</dd></div>
+          <div><dt>LAB</dt><dd>8 种策略 · 4 档长度</dd></div>
+        </dl>
+        <span class="release-arrow" aria-hidden="true">进入长上下文 →</span>
+      </a>
+    </div>
   </section>
 
   <section class="section" id="why">
@@ -323,12 +343,20 @@ const paths = [
       padding-bottom: 0;
     }
 
+    .release-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 22px;
+    }
+
     .release-card {
       position: relative;
       display: grid;
-      grid-template-columns: minmax(0, 1.45fr) minmax(280px, 0.65fr);
-      gap: clamp(34px, 6vw, 90px);
-      padding: clamp(28px, 4vw, 58px);
+      grid-template-rows: 1fr auto;
+      gap: 28px;
+      min-height: 560px;
+      padding: clamp(28px, 3.6vw, 50px);
+      padding-bottom: clamp(74px, 7vw, 92px);
       border: 1px solid var(--line-strong);
       color: inherit;
       text-decoration: none;
@@ -346,8 +374,8 @@ const paths = [
     .release-card h2 {
       max-width: 760px;
       margin: 20px 0 18px;
-      font-size: clamp(2rem, 4vw, 4.2rem);
-      line-height: 1.03;
+      font-size: clamp(2rem, 3.2vw, 3.5rem);
+      line-height: 1.05;
     }
 
     .release-card p:not(.eyebrow) {
@@ -358,7 +386,7 @@ const paths = [
     }
 
     .release-card dl {
-      margin: 0 0 28px;
+      margin: 0;
       border-top: 1px solid var(--line);
     }
 
@@ -391,8 +419,12 @@ const paths = [
     }
 
     @media (max-width: 760px) {
-      .release-card {
+      .release-grid {
         grid-template-columns: 1fr;
+      }
+
+      .release-card {
+        min-height: 0;
         padding-bottom: 76px;
       }
 
diff --git a/src/pages/k3/index.astro b/src/pages/k3/index.astro
index 56b923a..4d6d2ec 100644
--- a/src/pages/k3/index.astro
+++ b/src/pages/k3/index.astro
@@ -286,6 +286,7 @@ const toc = [
           这条技术线与 DeepSeekMoE 紧密相连：shared experts 保存公共知识，细粒度 routed experts 促进专业化。
           K3 再借 LatentMoE 让“选 16 个专家”的通信和权重读取可承受，并为极端稀疏补上稳定性机制。
         </p>
+        <a class="button primary" href="/moe/#k3">进入 MoE 专题：逐步推导 LatentMoE 与 Quantile Balancing →</a>
       </section>
 
       <section class="article-section" id="vision">
diff --git a/src/pages/moe/index.astro b/src/pages/moe/index.astro
new file mode 100644
index 0000000..6727cb1
--- /dev/null
+++ b/src/pages/moe/index.astro
@@ -0,0 +1,1680 @@
+---
+import BaseLayout from "@/layouts/BaseLayout.astro";
+import MoERoutingLab from "@/components/MoERoutingLab.astro";
+
+const toc = [
+  ["00", "map", "先拆成六张账单"],
+  ["01", "dense", "容量与算力怎样解绑"],
+  ["02", "history", "从软专家到稀疏门控"],
+  ["03", "pipeline", "一次 MoE 前向发生什么"],
+  ["04", "capacity", "容量、掉 Token 与稳定"],
+  ["05", "branches", "路由的几条分支"],
+  ["06", "deepseek", "DeepSeekMoE：切细与共享"],
+  ["07", "balance", "V2/V3：通信与无辅损"],
+  ["08", "latent", "LatentMoE：进入潜空间"],
+  ["09", "k3", "K3 Stable LatentMoE"],
+  ["10", "lab", "交互路由实验室"],
+  ["11", "systems", "MoonEP 与执行系统"],
+  ["12", "evaluation", "怎样判断专家真专"],
+  ["↳", "papers", "关键论文阅读链"],
+];
+
+const waves = [
+  {
+    year: "1991–94",
+    title: "让局部专家分工",
+    papers: "Adaptive MoE · Hierarchical MoE",
+    move: "门控网络学习输入空间划分，多个专家竞争解释样本。",
+    wall: "规模小、软混合，尚未解决大网络的每样本计算。",
+  },
+  {
+    year: "2017",
+    title: "只激活 top-k",
+    papers: "Sparsely-Gated MoE",
+    move: "Noisy Top-k 把巨大专家池变成条件计算，容量第一次可远快于激活算力增长。",
+    wall: "路由塌缩、专家不均和分布式执行变成新问题。",
+  },
+  {
+    year: "2020–22",
+    title: "进入 Transformer 与集群",
+    papers: "GShard · Switch · GLaM · ST-MoE",
+    move: "FFN 专家、自动切分、top-1/2、capacity 与专家并行形成现代栈。",
+    wall: "Token drop、All-to-All、训练稳定和迁移质量互相牵制。",
+  },
+  {
+    year: "2021–24",
+    title: "重写谁选谁",
+    papers: "BASE · Expert Choice · Soft MoE · MoD",
+    move: "均衡分配、专家选 Token、连续 slots 与按深度跳层探索不同条件计算。",
+    wall: "因果语言模型、解码、静态形状与主流内核限制部分路线。",
+  },
+  {
+    year: "2024–26",
+    title: "算法与系统共同设计",
+    papers: "DeepSeekMoE · Loss-Free · LatentMoE · K3",
+    move: "切细专家、共享共性、限域路由、潜空间载荷、分位数均衡与冗余专家规划汇流。",
+    wall: "理论 FLOPs 已不是唯一尺度，权重带宽、网络、稳定和服务部署同样决定成本。",
+  },
+];
+
+const paperChain = [
+  ["1991", "Adaptive Mixtures of Local Experts", "https://doi.org/10.1162/neco.1991.3.1.79", "门控与局部专家分工的概念起点。"],
+  ["1994", "Hierarchical Mixtures of Experts and the EM Algorithm", "https://www.cs.toronto.edu/~hinton/absps/hme.pdf", "树状门控与 EM 训练。"],
+  ["2017", "Sparsely-Gated Mixture-of-Experts", "https://arxiv.org/abs/1701.06538", "Noisy Top-k、负载目标与现代条件计算。"],
+  ["2020", "GShard", "https://arxiv.org/abs/2006.16668", "Top-2 Transformer MoE、自动切分和大规模翻译。"],
+  ["2021", "Switch Transformers", "https://arxiv.org/abs/2101.03961", "Top-1、capacity factor、token drop 与专家并行。"],
+  ["2021", "BASE Layers", "https://arxiv.org/abs/2103.16716", "把路由视作均衡分配问题。"],
+  ["2021", "GLaM", "https://arxiv.org/abs/2112.06905", "1.2T 语言模型中的 top-2 MoE。"],
+  ["2022", "ST-MoE", "https://arxiv.org/abs/2202.08906", "Router z-loss、稳定性、capacity 与迁移。"],
+  ["2022", "Expert Choice Routing", "https://arxiv.org/abs/2202.09368", "专家选择固定容量 Token。"],
+  ["2022", "MegaBlocks", "https://arxiv.org/abs/2211.15841", "以 block-sparse GPU kernels 避免因负载不均而丢 Token。"],
+  ["2023", "Soft MoE", "https://arxiv.org/abs/2308.00951", "用连续 dispatch/combine slots 替代硬 top-k。"],
+  ["2024", "Mixtral of Experts", "https://arxiv.org/abs/2401.04088", "开放生态中的每层 8 选 2。"],
+  ["2024", "DeepSeekMoE", "https://arxiv.org/abs/2401.06066", "细粒度专家分割与共享专家隔离。"],
+  ["2024", "Mixture-of-Depths", "https://arxiv.org/abs/2404.02258", "把条件计算从宽度扩到深度。"],
+  ["2024", "DeepSeek-V2", "https://arxiv.org/abs/2405.04434", "Device-limited routing 与规模化 DeepSeekMoE。"],
+  ["2024", "Auxiliary-Loss-Free Load Balancing", "https://arxiv.org/abs/2408.15664", "Selection bias 与 mixture weight 解耦。"],
+  ["2024", "DeepSeek-V3", "https://arxiv.org/abs/2412.19437", "256 选 8、node limit、no-drop 与 DualPipe。"],
+  ["2026", "LatentMoE", "https://arxiv.org/abs/2601.18089", "在潜空间 dispatch 和执行专家，优化 accuracy per cost。"],
+  ["2026", "Kimi K3", "https://arxiv.org/abs/2607.24653", "Stable LatentMoE、Quantile Balancing 与 MoonEP。"],
+];
+---
+
+<BaseLayout
+  title="稀疏计算与 MoE：从 Switch、DeepSeekMoE 到 Kimi K3"
+  description="把 Mixture-of-Experts 拆成容量、激活计算、路由、负载、通信与稳定性六张账单，沿关键论文理解 Switch、DeepSeekMoE、Loss-Free、LatentMoE 与 K3 Stable LatentMoE。"
+  section="moe"
+>
+  <header class="page-hero moe-hero">
+    <div class="page-hero-inner">
+      <div>
+        <p class="eyebrow"><span>ARCHITECTURE / 06</span> MIXTURE OF EXPERTS</p>
+        <h1>2.8T 参数，<br />不等于每个 Token 跑 2.8T</h1>
+        <p class="lead">
+          MoE 的核心不是“凭空省掉参数”，而是让不同 Token 只激活不同的专家子集。
+          它把容量与计算解绑，也把代价转移到路由、负载、显存带宽与跨设备 All‑to‑All。
+        </p>
+      </div>
+      <dl class="page-facts">
+        <div><dt>LEDGERS</dt><dd>6 张独立账单</dd></div>
+        <div><dt>CORE PAPERS</dt><dd>19 篇一手来源</dd></div>
+        <div><dt>LINEAGE</dt><dd>1991 → 2026</dd></div>
+        <div><dt>LAB</dt><dd>8 架构 · 4 均衡模式</dd></div>
+        <div><dt>ENDPOINT</dt><dd>DeepSeek ↔ Kimi K3</dd></div>
+      </dl>
+    </div>
+  </header>
+
+  <div class="report-shell">
+    <aside class="side-rail" aria-label="本页目录">
+      <p>CONTENTS</p>
+      <ol>
+        {toc.map(([number, id, label]) => (
+          <li><a href={`#${id}`}><span>{number}</span>{label}</a></li>
+        ))}
+      </ol>
+      <div class="rail-note">
+        <b>研究截止</b>
+        2026-07-28。参数与性能数字沿用各论文口径；交互负载为教学模拟。
+      </div>
+    </aside>
+
+    <article class="article">
+      <section class="article-section" id="map">
+        <p class="eyebrow"><span>00</span> SIX LEDGERS</p>
+        <h2>“更大但更便宜”只有拆成六笔账才成立</h2>
+        <p class="lede">
+          稠密模型里，增加 FFN 宽度会同时增加参数、每 Token FLOPs 和权重读取。
+          MoE 用条件路由拆开三者，却不是免费午餐：模型越稀疏，越需要为不均匀的动态执行付账。
+        </p>
+
+        <div class="ledger-grid">
+          <article>
+            <span>L1 / CAPACITY</span><b>总参数</b><strong>模型存了多少权重？</strong>
+            <p>决定知识容量、存储、加载和分片压力；不会因为某个 Token 没激活它就消失。</p>
+          </article>
+          <article>
+            <span>L2 / COMPUTE</span><b>激活参数</b><strong>这次前向用了多少？</strong>
+            <p>Top-k 只执行少数 routed experts，但 attention、共享专家和投影仍是稠密路径。</p>
+          </article>
+          <article>
+            <span>L3 / ROUTING</span><b>专家选择</b><strong>谁去哪里？</strong>
+            <p>Router 的 score、top-k、共享路径和限域约束共同决定每个 Token 的计算图。</p>
+          </article>
+          <article>
+            <span>L4 / LOAD</span><b>容量与均衡</b><strong>会不会有人排爆？</strong>
+            <p>热门专家过载会让设备等待、形状波动，早期实现还会直接跳过溢出的专家计算。</p>
+          </article>
+          <article>
+            <span>L5 / NETWORK</span><b>Dispatch / Combine</b><strong>Token 搬多远？</strong>
+            <p>专家分布到不同设备后，前后两次 All-to-All 可能把理论省下的计算时间吃回去。</p>
+          </article>
+          <article>
+            <span>L6 / STABILITY</span><b>硬切换与数值</b><strong>训练会不会崩？</strong>
+            <p>Router logits、辅助损失、潜空间连续矩阵乘与极端稀疏都可能制造独立故障。</p>
+          </article>
+        </div>
+
+        <div class="plain-language">
+          <b>图书馆比喻：书库很大，不代表每位读者搬走全部书</b>
+          <p>
+            稠密 FFN 像每个问题都由同一支超大团队完整处理；MoE 像先由调度台判断领域，再叫少数专家组接单。
+            团队名册可以很大，但每单只付少数人的计算工资。新的麻烦是：热门专家会排队，不同楼层之间要搬材料，
+            调度台也可能永远只叫同一批人。
+          </p>
+        </div>
+      </section>
+
+      <section class="article-section" id="dense">
+        <p class="eyebrow"><span>01</span> CAPACITY ≠ ACTIVE COMPUTE</p>
+        <h2>先看懂稠密 FFN，才知道 MoE 替换了什么</h2>
+        <p>
+          Decoder-only Transformer 的每层通常有 attention 和 FFN。Attention 在 Token 之间混合信息；
+          FFN 则对每个位置独立做通道变换。模型的大部分参数往往在 FFN 中，因此现代 MoE 通常不替换整个 Transformer，
+          而是把若干层的一个 FFN 换成许多份专家 FFN。
+        </p>
+
+        <div class="dense-moe-visual">
+          <div class="dense-side">
+            <span>DENSE FFN</span>
+            <div class="token-row"><i>t₁</i><i>t₂</i><i>t₃</i><i>t₄</i></div>
+            <b>同一组巨大权重</b>
+            <div class="weight-wall">{Array.from({ length: 36 }, () => <i></i>)}</div>
+            <p>每个 Token 读取、计算同一套 FFN。</p>
+          </div>
+          <div class="moe-side">
+            <span>SPARSE MOE</span>
+            <div class="token-row routed"><i>t₁</i><i>t₂</i><i>t₃</i><i>t₄</i></div>
+            <b>Router → 少数专家</b>
+            <div class="expert-shelf">
+              {Array.from({ length: 12 }, (_, index) => <i data-hot={index === 1 || index === 5 || index === 9 ? "" : undefined}>E{index + 1}</i>)}
+            </div>
+            <p>专家都存着，但每个 Token 只读取 top-k。</p>
+          </div>
+        </div>
+
+        <div class="formula-stack">
+          <div>
+            <span>DENSE</span>
+            <b>y = FFN(x)</b>
+            <p>唯一计算路径；容量增加通常同步增加每 Token FLOPs。</p>
+          </div>
+          <div>
+            <span>SPARSE MOE</span>
+            <b>y = Σ<sub>i∈TopK(x)</sub> pᵢ(x) · Eᵢ(x)</b>
+            <p>Router 决定集合，门控权重 pᵢ 合并已选专家输出。</p>
+          </div>
+        </div>
+
+        <h3>三个经常被混用的数字</h3>
+        <div class="number-cards">
+          <article><span>TOTAL PARAMS</span><b>2.8T</b><p>K3 存储的全部模型权重口径。</p></article>
+          <article><span>ACTIVATED PARAMS</span><b>104.2B</b><p>K3 报告的每 Token 激活参数口径；包含的不只 16 个 routed experts。</p></article>
+          <article><span>ROUTED EXPERT RATIO</span><b>16 / 896</b><p>只有 1.79%，但不能直接拿它乘 2.8T 推导 activated params。</p></article>
+        </div>
+        <div class="warning-note">
+          <b>为什么 2.8T × 16/896 不是 104B 的算法</b>
+          <p>
+            总参数里还包含 attention、embedding、latent 上下投影、两个 full-width shared experts 等稠密或固定路径；
+            routed experts 的参数形状也与这些模块不同。跨模型比较时必须沿用报告给出的 active parameter 口径。
+          </p>
+        </div>
+      </section>
+
+      <section class="article-section" id="history">
+        <p class="eyebrow"><span>02</span> FIVE WAVES</p>
+        <h2>MoE 的历史，是每解决一笔算力账就暴露一笔系统账</h2>
+        <p>
+          1991 年的 <a href="https://doi.org/10.1162/neco.1991.3.1.79">Adaptive Mixtures of Local Experts</a>
+          已经有专家和 gate，但今天 LLM 里的 MoE 还需要稀疏 top-k、静态 batch 形状、设备切分和高性能通信。
+          因此“概念发明”和“可扩展 Transformer MoE”之间隔了二十多年。
+        </p>
+        <div class="wave-timeline">
+          {waves.map((wave, index) => (
+            <article>
+              <div class="wave-index">{String(index + 1).padStart(2, "0")}</div>
+              <time>{wave.year}</time>
+              <div>
+                <h3>{wave.title}</h3>
+                <b>{wave.papers}</b>
+                <p>{wave.move}</p>
+                <small>留下的墙：{wave.wall}</small>
+              </div>
+            </article>
+          ))}
+        </div>
+
+        <h3>2017 的关键改变：从“加权所有专家”到“只执行 top-k”</h3>
+        <p>
+          <a href="https://arxiv.org/abs/1701.06538">Sparsely-Gated MoE</a> 用 Noisy Top-k Gating
+          在巨大专家池中只保留少数非零 gate。稀疏执行让参数容量增长快于计算增长，同时用噪声与负载目标鼓励探索。
+          这篇论文把条件计算从一个好想法推进成现代大模型可继承的模块，但也正式引入路由塌缩：如果 gate 总偏爱少数专家，
+          其他专家得不到训练，热门设备又成为整步瓶颈。
+        </p>
+      </section>
+
+      <section class="article-section" id="pipeline">
+        <p class="eyebrow"><span>03</span> ONE FORWARD PASS</p>
+        <h2>一次 MoE 前向不是一个算子，而是一条物流链</h2>
+        <p>
+          在单卡伪代码里，MoE 看起来只是 top-k 加几次矩阵乘。进入 Expert Parallelism 后，
+          专家被分散到不同 GPU；Token 起初在数据所属设备上，必须先按路由重排，再把结果运回原位置。
+        </p>
+
+        <div class="pipeline-visual">
+          <article>
+            <span>01 / SCORE</span><b>Router</b>
+            <div class="score-bars"><i></i><i></i><i></i><i></i><i></i><i></i></div>
+            <p>为每个 Token 计算专家 affinity。</p>
+          </article>
+          <i>→</i>
+          <article>
+            <span>02 / SELECT</span><b>Top-k</b>
+            <div class="topk"><i>E₂</i><i>E₇</i><i>E₉</i></div>
+            <p>只保留少数专家；共享专家可绕过 router 固定执行。</p>
+          </article>
+          <i>→</i>
+          <article>
+            <span>03 / DISPATCH</span><b>All-to-All</b>
+            <div class="network-mini"><i></i><i></i><i></i><i></i></div>
+            <p>Token 搬到专家所在设备并按 expert 分组。</p>
+          </article>
+          <i>→</i>
+          <article>
+            <span>04 / EXPERT</span><b>Grouped GEMM</b>
+            <div class="gemm-mini"><i></i><i></i><i></i></div>
+            <p>不同专家处理长度不同的小批 Token。</p>
+          </article>
+          <i>→</i>
+          <article>
+            <span>05 / COMBINE</span><b>Return + Weight</b>
+            <div class="combine-mini"><i></i><i></i><b>Σ</b></div>
+            <p>第二次通信，恢复原 Token 顺序并按 gate 合并。</p>
+          </article>
+        </div>
+
+        <div class="cost-ledger">
+          <div><span>理论专家 FLOPs</span><b>≈ T · k · expert_size</b><p>k 小时远低于执行全部 N 个专家。</p></div>
+          <div><span>专家权重读取</span><b>取决于 batch / expert</b><p>小 batch 下每专家 Token 少，常被 HBM 带宽限制。</p></div>
+          <div><span>通信载荷</span><b>≈ 2 · T · k · routed_width</b><p>两次通信；协议、对齐和梯度会继续加成本。</p></div>
+        </div>
+      </section>
+
+      <section class="article-section" id="capacity">
+        <p class="eyebrow"><span>04</span> CAPACITY · DROP · STABILITY</p>
+        <h2>Router 选得很聪明，也可能让硬件跑得很笨</h2>
+        <p>
+          早期 TPU/SPMD 实现要求专家 batch 形状在编译时确定。假设一批有 T 个 Token、N 个专家、每 Token 激活 k 个专家，
+          理想平均负载约为 Tk/N。Capacity factor（CF）给这个平均数加缓冲：
+        </p>
+        <div class="formula">
+          expert capacity ≈ ⌈CF × T × k / N⌉
+          <small>Switch 原式是 top-1 的 T/N × CF；这里写成常用 top-k 教学推广。具体实现的 group 与取整口径不同。</small>
+        </div>
+
+        <div class="capacity-demo">
+          <div class="capacity-copy">
+            <span>HAND CALCULATION</span>
+            <h3>512 Token · 16 专家 · top-2</h3>
+            <p>平均每专家 512×2/16 = 64 条 route。</p>
+            <dl>
+              <div><dt>CF = 1.00</dt><dd>每专家容量 64</dd></div>
+              <div><dt>CF = 1.25</dt><dd>每专家容量 80</dd></div>
+              <div><dt>CF = 2.00</dt><dd>每专家容量 128</dd></div>
+            </dl>
+          </div>
+          <div class="capacity-bins">
+            <article><b>E₁</b><i style="--load:92%;--cap:64%"></i><small>热门 · overflow</small></article>
+            <article><b>E₂</b><i style="--load:72%;--cap:64%"></i><small>轻微溢出</small></article>
+            <article><b>E₃</b><i style="--load:43%;--cap:64%"></i><small>空槽浪费</small></article>
+            <article><b>E₄</b><i style="--load:24%;--cap:64%"></i><small>接近闲置</small></article>
+          </div>
+        </div>
+
+        <p>
+          Switch 对溢出 Token 跳过专家计算，让表示沿残差进入下一层；论文主要实验报告 dropped tokens 通常低于 1%，
+          但这不是 MoE 的自然定律。把 CF 拉高可减少 overflow，却线性增加 padding、激活内存、einsum 和 All-to-All 成本。
+          ST-MoE 进一步表明最优 CF 依赖硬件：它的 32B 模型从 1.25 拉到 2.0，step time 增加 14%，质量增益却较小。
+        </p>
+
+        <h3>三个不同问题，不能都叫“负载均衡”</h3>
+        <div class="stability-grid">
+          <article>
+            <span>A / AUX BALANCE</span><b>谁被用了多少</b>
+            <p>用额外 loss 让实际路由比例与平均 gate 概率都接近均匀；过强会把干扰梯度加进主训练。</p>
+          </article>
+          <article>
+            <span>B / ROUTER Z-LOSS</span><b>logits 会不会爆大</b>
+            <p>ST-MoE 惩罚 router log-partition 的平方，减少指数函数前的大数与舍入风险；它不直接分配容量。</p>
+          </article>
+          <article>
+            <span>C / SYSTEM BALANCE</span><b>每张卡何时完成</b>
+            <p>即使专家平均负载相等，专家到 rank 的映射、组内长尾和通信路径仍可能让设备 makespan 不同。</p>
+          </article>
+        </div>
+      </section>
+
+      <section class="article-section" id="branches">
+        <p class="eyebrow"><span>05</span> ROUTING BRANCHES</p>
+        <h2>Top-k 不是唯一答案，但因果 LM 与硬件会筛掉很多漂亮方案</h2>
+        <div class="branch-grid">
+          <article>
+            <span>BASE / 2021</span><h3>把路由做成均衡分配</h3>
+            <p>直接求 Token–expert 的 balanced assignment，减少靠辅助损失慢慢“劝”均衡。</p>
+            <small>代价：分配求解与主流在线 top-k 栈不同。</small>
+          </article>
+          <article>
+            <span>EXPERT CHOICE / 2022</span><h3>反过来让专家选 Token</h3>
+            <p>每个专家拿固定 bucket，专家侧天然满载；不同 Token 可被 0、1 或多个专家处理。</p>
+            <small>因果风险：同一 chunk 的未来 Token 可影响前面 Token 是否被专家选中。</small>
+          </article>
+          <article>
+            <span>SOFT MOE / 2023</span><h3>不用硬 top-k</h3>
+            <p>先把 Token 连续混成固定 slots，让专家处理 slots，再连续 combine 回 Token。</p>
+            <small>代价：信息路径和传统稀疏 EP 不同，硬专业化直觉也改变。</small>
+          </article>
+          <article>
+            <span>MIXTURE OF DEPTHS / 2024</span><h3>条件计算不只在宽度</h3>
+            <p>固定每层可处理的 Token 容量，让重要 Token 进块、不重要 Token 跳过。</p>
+            <small>它改变“走多深”，可与专家宽度 MoE 组合，但调度更复杂。</small>
+          </article>
+        </div>
+        <div class="warning-note">
+          <b>Expert Choice 为什么对自回归语言模型尤其敏感</b>
+          <p>
+            如果专家在一个包含多个时间位置的 bucket 中挑最高分 Token，后面的 Token 会改变前面 Token 是否入选，
+            等于通过路由图泄露未来信息。Loss-Free 论文因此强调：训练因果 LM 时，均衡算法本身也必须遵守因果约束。
+          </p>
+        </div>
+      </section>
+
+      <section class="article-section" id="deepseek">
+        <p class="eyebrow"><span>06</span> DEEPSEEK SPOTLIGHT · SPECIALIZATION</p>
+        <h2>DeepSeekMoE 的关键不是“专家多”，而是同预算下切得更细</h2>
+        <p>
+          DeepSeekMoE 把传统粗专家的失败描述成两类：一个专家接收过多类型知识，形成
+          <strong>knowledge hybridity</strong>；不同专家都要重复学习常识，形成
+          <strong>knowledge redundancy</strong>。它用 fine-grained expert segmentation 与 shared expert isolation
+          分别回应这两个问题。
+        </p>
+
+        <div class="segmentation-visual">
+          <div>
+            <span>CONVENTIONAL</span>
+            <h3>16 个粗专家 · 选 2</h3>
+            <div class="coarse-experts">
+              {Array.from({ length: 16 }, (_, index) => <i data-on={index === 2 || index === 10 ? "" : undefined}>E{index + 1}</i>)}
+            </div>
+            <b>C(16,2) = 120</b>
+            <p>每个专家很宽，单个专家更容易混入多种知识。</p>
+          </div>
+          <i>保持总专家参数与激活计算</i>
+          <div>
+            <span>FINE-GRAINED</span>
+            <h3>64 个小专家 · 选 8</h3>
+            <div class="fine-experts">
+              {Array.from({ length: 64 }, (_, index) => <i data-on={index % 9 === 2 ? "" : undefined}></i>)}
+            </div>
+            <b>C(64,8) = 4,426,165,368</b>
+            <p>组合更灵活；组合数只是表达空间上限，不是已学会技能数。</p>
+          </div>
+        </div>
+
+        <h3>Shared expert isolation：先把共性工作拿出来</h3>
+        <div class="shared-visual">
+          <div class="shared-path">
+            <span>ALWAYS ON</span><b>共享专家</b>
+            <p>所有 Token 都经过，集中承载基础与共性变换。</p>
+          </div>
+          <div class="router-path">
+            <span>TOP-K</span><b>路由专家池</b>
+            <div>{Array.from({ length: 15 }, (_, index) => <i data-on={index % 4 === 1 ? "" : undefined}></i>)}</div>
+            <p>减少重复负担，更专注差异知识。</p>
+          </div>
+        </div>
+        <p>
+          2B 实验中，DeepSeekMoE 使用 1 个共享专家和 63 个 routed experts，每 Token 激活 1+7。
+          在保持计算相近时，禁用 shared expert 并多开一个 routed expert，Pile loss 从 1.808 升到 2.414。
+          这个实验支持共享路径确实学到难以被临时路由替代的共性知识；它不是所有规模上的固定幅度。
+        </p>
+      </section>
+
+      <section class="article-section" id="balance">
+        <p class="eyebrow"><span>07</span> DEEPSEEK V2 → V3</p>
+        <h2>专家切细以后，DeepSeek 必须接着解决自己制造的通信扇出</h2>
+        <div class="deepseek-evolution">
+          <article>
+            <time>V2</time><h3>Device-limited routing</h3>
+            <p>先挑少数目标设备，再在这些设备上的专家中完成 top-k，限制每 Token 的通信目的地。</p>
+            <small>同时保留 expert/device/communication 多类 auxiliary balance objectives。</small>
+          </article>
+          <i>→</i>
+          <article>
+            <time>V3</time><h3>Node-limited routing</h3>
+            <p>每 Token 最多发到 4 个节点；每层 1 shared + 256 routed，激活 8 routed。</p>
+            <small>把通信限制提升到 NVLink 节点域，并用 DualPipe 重叠计算和 All-to-All。</small>
+          </article>
+          <i>→</i>
+          <article>
+            <time>V3</time><h3>Auxiliary-loss-free bias</h3>
+            <p>用历史负载调 expert bias，让过热专家更难入选、冷门专家更容易入选。</p>
+            <small>报告称训练/推理 no token-dropping，但服务还使用冗余专家与周期性重排。</small>
+          </article>
+        </div>
+
+        <h3>最关键的解耦：选谁，与选中后占多大权重</h3>
+        <div class="selection-weight">
+          <div>
+            <span>SELECTION LANE</span>
+            <b>sᵢ + bᵢ → Top-k</b>
+            <p>Bias 只影响调度。过载专家下一步 bias 下降，欠载专家上升。</p>
+          </div>
+          <i>≠</i>
+          <div>
+            <span>MIXTURE LANE</span>
+            <b>pᵢ ∝ sᵢ</b>
+            <p>被选专家的实际输出权重仍来自原始 affinity，不把 bias 混进专家贡献。</p>
+          </div>
+        </div>
+
+        <p>
+          传统 auxiliary loss 把“请均匀”写进训练目标，系数太小压不住塌缩，太大又和语言建模梯度争方向。
+          Loss-Free Balancing 用非梯度 bias 更新 dispatch，论文在最高 3B、200B Token 的实验中取得更低 perplexity 与更好负载。
+          DeepSeek-V3 将其扩到 671B-A37B，并在 14.8T Token 训练中使用。
+        </p>
+        <div class="warning-note">
+          <b>“Auxiliary-loss-free”不是“V3 完全没有任何 balance loss”</b>
+          <p>
+            V3 的主均衡来自 batch-wise expert bias，但报告还保留系数 0.0001 的 sequence-wise auxiliary loss，
+            只用于防止单条序列内部出现极端失衡。严谨表述应是：去掉主要的 expert-level auxiliary balancing 梯度，
+            不是删除所有与平衡有关的正则项。
+          </p>
+        </div>
+      </section>
+
+      <section class="article-section" id="latent">
+        <p class="eyebrow"><span>08</span> LATENT MOE</p>
+        <h2>当 FLOPs 已经稀疏，下一堵墙是权重带宽和 Token 载荷宽度</h2>
+        <p>
+          标准 routed expert 接收完整模型宽度 d。小 batch 时，每个专家只得到少量 Token，GPU 花更多时间从 HBM
+          读取不同专家权重；大吞吐 Expert Parallel 时，All-to-All 又要搬运 k 份 d 维 Token。
+          <a href="https://arxiv.org/abs/2601.18089">LatentMoE</a> 因此不先减少 k，而是减少 routed width。
+        </p>
+
+        <div class="latent-visual">
+          <div class="standard-path">
+            <span>STANDARD MOE</span>
+            <i>x ∈ Rᵈ</i><b>DISPATCH d</b><strong>Experts in d</strong><b>COMBINE d</b><i>y ∈ Rᵈ</i>
+            <p>每条路由搬完整模型宽度；专家权重也以 d 为输入/输出宽度。</p>
+          </div>
+          <div class="latent-path">
+            <span>LATENT MOE</span>
+            <i>x ∈ Rᵈ</i><b>W↓ : d → ℓ</b><strong>Route + Experts in ℓ</strong><b>W↑ : ℓ → d</b><i>y ∈ Rᵈ</i>
+            <p>共享专家仍可走全宽；routed path 的通信与权重流量约按 d/ℓ 压缩。</p>
+          </div>
+        </div>
+
+        <div class="latent-variants">
+          <article>
+            <span>ℓ-MoE<sub>eff</sub></span><h3>把节省换成效率</h3>
+            <p>压缩 d→ℓ，并按 α=d/ℓ 增加总专家 N；top-k 不变，主要降低 active params / cost。</p>
+          </article>
+          <article>
+            <span>ℓ-MoE<sub>acc</sub></span><h3>把节省换成更多组合</h3>
+            <p>同时把 N 和 k 放大 α 倍，让通信和带宽近似不增，却提升专家组合与非线性预算。</p>
+          </article>
+        </div>
+        <p>
+          论文在 16B/2B active 与 95B/8B active 模型上探索，主要后续实验使用 α=4；
+          ℓ-MoE<sub>acc</sub> 在其 95B 对比中以相近 total/active 参数提高多个任务准确率。
+          论文的万亿参数 Kimi-K2 serving 图来自高保真模拟器与 effective-parameter construction，
+          因而本课程把它标成 projected result，不写成真实线上基准。
+        </p>
+      </section>
+
+      <section class="article-section" id="k3">
+        <p class="eyebrow"><span>09</span> KIMI K3 · STABLE LATENTMOE</p>
+        <h2>“Stable”不是修饰词：它对应极端稀疏下三种具体修复</h2>
+        <p>
+          K3 把模型宽度 7168 投到 3584 维 latent routed path，用 896 个 routed experts 取 16 个，
+          另有 2 个全宽 shared experts。更大的专家池与更高 k 扩张专业化空间，却把原 LatentMoE
+          推进了一个新故障区间。
+        </p>
+
+        <div class="k3-spec">
+          <article><span>TOTAL / ACTIVE</span><b>2.78T / 104.2B</b></article>
+          <article><span>ROUTED EXPERTS</span><b>896 → 16</b></article>
+          <article><span>SHARED EXPERTS</span><b>2 · always on</b></article>
+          <article><span>MODEL → LATENT</span><b>7168 → 3584</b></article>
+          <article><span>EXPERT HIDDEN</span><b>3072</b></article>
+          <article><span>ROUTED SPARSITY</span><b>56×</b></article>
+        </div>
+
+        <div class="stable-fixes">
+          <article>
+            <span>FIX 01 / SCALE</span><h3>Normalized LatentMoE</h3>
+            <p>多个 routed experts 聚合后的 latent u 尺度会随 gate 与专家变化；K3 在 W↑ 前加入 RMSNorm，再与共享路径相加。</p>
+          </article>
+          <article>
+            <span>FIX 02 / ACTIVATION</span><h3>SiTU-GLU</h3>
+            <p>W↓、多分支 gated expert、W↑ 形成近四连矩阵乘；有界 tanh soft-cap 控制 SwiGLU 两个乘法分支的极值。</p>
+            <small>报告配置 β₁=4、β₂=25，标量输出上界为 100。</small>
+          </article>
+          <article>
+            <span>FIX 03 / BALANCE</span><h3>Quantile Balancing</h3>
+            <p>固定步长 bias 在近 10³ 专家下会面临“反应慢 vs 振荡”；QB 直接从 score margin 的目标 quantile 算下一步 bias。</p>
+          </article>
+        </div>
+
+        <h3>Quantile Balancing：从“每次推一点”变成“直接找负载阈值”</h3>
+        <div class="qb-flow">
+          <article><span>01</span><b>Top-(k+1)</b><p>前 k 个是真路由，第 k+1 个给出每个 Token 的入选 cutoff αᵢ。</p></article>
+          <i>→</i>
+          <article><span>02</span><b>Margin</b><p>对专家 j 计算所有 Token 的 raw score sᵢⱼ 减 cutoff αᵢ。</p></article>
+          <i>→</i>
+          <article><span>03</span><b>Quantile</b><p>目标负载 q=mk/n，对 margin 取 1-k/n 分位数得到下一步 bias。</p></article>
+          <i>→</i>
+          <article><span>04</span><b>Next step</b><p>Bias 下一批才生效；推理时冻结，遵守 causal LM 约束。</p></article>
+        </div>
+
+        <p>
+          全局 batch 有数百万 margin，无法把它们全收集到一处精确排序。K3 用每专家直方图统计，
+          通过一次 all-reduce 合并 bin counts，再从累计直方图读 quantile。这里体现了很典型的算法—系统协同：
+          数学目标是分位数，工程实现则把全局排序改写成固定大小的可加统计。
+        </p>
+      </section>
+
+      <section class="article-section wide-break" id="lab">
+        <p class="eyebrow"><span>10</span> INTERACTIVE LAB</p>
+        <h2>亲手制造路由塌缩，再看每种方法到底改了哪张账</h2>
+        <p>
+          先从 Switch 开始，把路由偏斜拉高、capacity factor 降到 0.75；再依次切换 Aux proxy、Loss-Free 和 QB proxy。
+          最后比较 DeepSeek-V3 的 node limit、LatentMoE 的 4× payload 压缩与 K3 的 896 选 16。
+        </p>
+        <MoERoutingLab />
+      </section>
+
+      <section class="article-section" id="systems">
+        <p class="eyebrow"><span>11</span> MOONEP · EXECUTION</p>
+        <h2>Router 均匀，不代表每张 GPU 同时下班</h2>
+        <p>
+          Quantile Balancing 主要在专家选择层面逼近目标负载；真正训练 3T 模型时，还要把专家映射到 EP ranks，
+          安排 redundant experts、通信 buffer、Grouped GEMM 与 shared expert stream。K3 的 MoonEP
+          用在线冗余专家规划把“平均均衡”推进到“每个 rank 完全等量执行”。
+        </p>
+
+        <div class="rank-balance">
+          <div class="imbalanced-ranks">
+            <span>CONVENTIONAL EP</span>
+            <article><b>R1</b><i style="--rank:92%"></i><small>等待</small></article>
+            <article><b>R2</b><i style="--rank:48%"></i><small>空闲</small></article>
+            <article><b>R3</b><i style="--rank:74%"></i><small>等待</small></article>
+            <article><b>R4</b><i style="--rank:31%"></i><small>空闲</small></article>
+          </div>
+          <i>在线规划<br />冗余专家</i>
+          <div class="balanced-ranks">
+            <span>MOONEP</span>
+            <article><b>R1</b><i></i><small>S×K</small></article>
+            <article><b>R2</b><i></i><small>S×K</small></article>
+            <article><b>R3</b><i></i><small>S×K</small></article>
+            <article><b>R4</b><i></i><small>S×K</small></article>
+          </div>
+        </div>
+
+        <div class="system-grid">
+          <article><span>BOUNDED REDUNDANCY</span><h3>至多 E/R 槽</h3><p>报告证明每 rank 预留这个上界即可保证存在可行平衡计划。</p></article>
+          <article><span>ZERO COPY</span><h3>直接写入 expert-grouped buffer</h3><p>Planning kernel 预先给出目的地，fused permute/unpermute 减少中间 copy。</p></article>
+          <article><span>STATIC SHAPES</span><h3>每 rank 固定 S×K</h3><p>消除每层读取动态 shape 的 host sync，也压低内存碎片。</p></article>
+          <article><span>OVERLAP</span><h3>Shared / routed 分流</h3><p>共享专家独立 stream；dispatch/combine 与其他计算阶段重叠。</p></article>
+        </div>
+      </section>
+
+      <section class="article-section" id="evaluation">
+        <p class="eyebrow"><span>12</span> EVIDENCE</p>
+        <h2>怎样判断专家真的“专”，而不只是路由图看起来热闹</h2>
+        <div class="evidence-ladder">
+          <article><span>L1</span><h3>训练与验证 loss</h3><p>在相同 total params、active params、FLOPs 与训练 Token 下比较，避免“更多计算”冒充架构收益。</p></article>
+          <article><span>L2</span><h3>负载指标</h3><p>同时看全局、batch、sequence、rank 与 per-expert makespan；一个平均数会隐藏长尾。</p></article>
+          <article><span>L3</span><h3>干预专家</h3><p>禁用高分专家、共享专家或改变激活 k，看 loss 退化是否说明专家不可替代。</p></article>
+          <article><span>L4</span><h3>领域路由</h3><p>比较代码、数学、自然语言等域的 load pattern，但不要把相关性直接命名成可解释技能。</p></article>
+          <article><span>L5</span><h3>系统测量</h3><p>端到端 tokens/s、p50/p99、HBM traffic、All-to-All、空槽、掉 Token 与容错必须同看。</p></article>
+          <article><span>L6</span><h3>部署口径</h3><p>Prefill 与 decode 的 expert batch 不同；训练均衡方案不保证小 batch 在线服务同样均衡。</p></article>
+        </div>
+
+        <div class="fact-split">
+          <div>
+            <span>PAPER FACT</span>
+            <p>K3 报告公开 2.78T/104.2B、896→16、2 shared、QB 数学式和 MoonEP 设计。</p>
+          </div>
+          <div>
+            <span>REASONABLE INFERENCE</span>
+            <p>更大组合空间提供更细专业化机会，但 C(N,k) 不是能力数量，也不保证自动形成可解释专家。</p>
+          </div>
+          <div>
+            <span>STILL UNKNOWN</span>
+            <p>完整训练数据、线上请求分布、真实专家语义、长期失效模式与第三方 3T 复现仍不公开。</p>
+          </div>
+        </div>
+      </section>
+
+      <section class="article-section" id="papers">
+        <p class="eyebrow"><span>↳</span> PRIMARY-SOURCE READING ORDER</p>
+        <h2>按问题读 19 篇论文，而不是按模型名背配置</h2>
+        <div class="paper-chain moe-chain">
+          {paperChain.map(([year, title, url, note]) => (
+            <a class="paper-row" href={url}>
+              <time>{year}</time><b>{title}</b><p>{note}</p>
+            </a>
+          ))}
+        </div>
+        <div class="source-footer">
+          <div>
+            <span>LOCAL RESEARCH LEDGER</span>
+            <p>
+              本专题的原文页码、边界和核验结论记录于开源仓库
+              <code>research/MOE_RESEARCH.md</code>；PDF 只在本地研究缓存中保存。
+            </p>
+          </div>
+          <div>
+            <span>HOW TO CONTINUE</span>
+            <p>下一专题会沿 CoT、verifier、GRPO、R1、k1.5 和 K3 MOPD 进入推理模型与测试时扩展。</p>
+          </div>
+        </div>
+        <div class="next-links">
+          <a class="button primary" href="/k3/#moe">回到 K3：在整机架构中定位 Stable LatentMoE →</a>
+          <a class="button" href="/deepseek/">DeepSeek 完整论文谱系</a>
+          <a class="button" href="/papers/">搜索全部 130 篇论文</a>
+        </div>
+      </section>
+    </article>
+  </div>
+</BaseLayout>
+
+<style>
+  .moe-hero::before {
+    background:
+      radial-gradient(circle at 76% 31%, rgba(150, 93, 58, 0.12), transparent 26%),
+      radial-gradient(circle at 60% 50%, rgba(77, 119, 105, 0.14), transparent 31%);
+  }
+
+  .ledger-grid {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    margin: 38px 0;
+    border-top: 1px solid var(--line);
+    border-left: 1px solid var(--line);
+  }
+
+  .ledger-grid article {
+    min-height: 245px;
+    padding: 24px;
+    border-right: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .ledger-grid span,
+  .dense-moe-visual span,
+  .formula-stack span,
+  .number-cards span,
+  .capacity-copy > span,
+  .stability-grid span,
+  .branch-grid article > span,
+  .segmentation-visual > div > span,
+  .shared-visual span,
+  .selection-weight span,
+  .latent-visual span,
+  .latent-variants span,
+  .k3-spec span,
+  .stable-fixes article > span,
+  .rank-balance > div > span,
+  .system-grid article > span,
+  .fact-split span,
+  .source-footer span {
+    color: var(--copper);
+    font: 0.6rem/1.4 var(--mono);
+    letter-spacing: 0.09em;
+  }
+
+  .ledger-grid b {
+    display: block;
+    margin: 28px 0 13px;
+    font-family: var(--serif);
+    font-size: 1.35rem;
+  }
+
+  .ledger-grid strong {
+    display: block;
+    min-height: 38px;
+    color: var(--ink-soft);
+    font-size: 0.82rem;
+  }
+
+  .ledger-grid p,
+  .branch-grid p,
+  .system-grid p {
+    color: var(--ink-soft);
+    font-size: 0.88rem;
+    line-height: 1.7;
+  }
+
+  .plain-language {
+    margin: 38px 0;
+    padding: 28px 32px;
+    border-left: 4px solid var(--copper);
+    background: var(--paper-shadow);
+  }
+
+  .plain-language b {
+    font-family: var(--serif);
+    font-size: 1.12rem;
+  }
+
+  .plain-language p {
+    margin-bottom: 0;
+    color: var(--ink-soft);
+  }
+
+  .dense-moe-visual {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    margin: 36px 0;
+    border: 1px solid var(--line);
+  }
+
+  .dense-moe-visual > div {
+    min-height: 420px;
+    padding: clamp(26px, 4vw, 42px);
+  }
+
+  .dense-side {
+    border-right: 1px solid var(--line);
+  }
+
+  .dense-moe-visual h3,
+  .dense-moe-visual > div > b {
+    display: block;
+    margin: 26px 0 18px;
+    font-family: var(--serif);
+    font-size: 1.45rem;
+  }
+
+  .token-row {
+    display: flex;
+    gap: 8px;
+    margin: 24px 0;
+  }
+
+  .token-row i {
+    display: grid;
+    place-items: center;
+    width: 42px;
+    height: 32px;
+    border: 1px solid var(--line-strong);
+    font: normal 0.66rem/1 var(--mono);
+  }
+
+  .token-row.routed i:nth-child(2n) {
+    color: var(--paper);
+    background: var(--navy);
+  }
+
+  .weight-wall {
+    display: grid;
+    grid-template-columns: repeat(9, 1fr);
+    gap: 5px;
+    padding: 16px;
+    background: var(--navy);
+  }
+
+  .weight-wall i {
+    aspect-ratio: 1;
+    background: rgba(245, 242, 234, 0.22);
+  }
+
+  .expert-shelf {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 8px;
+  }
+
+  .expert-shelf i {
+    display: grid;
+    place-items: center;
+    min-height: 48px;
+    border: 1px solid var(--line);
+    color: var(--ink-muted);
+    font: normal 0.62rem/1 var(--mono);
+  }
+
+  .expert-shelf i[data-hot] {
+    border-color: var(--copper);
+    color: var(--paper);
+    background: var(--copper);
+  }
+
+  .dense-moe-visual p {
+    color: var(--ink-muted);
+    font-size: 0.82rem;
+  }
+
+  .formula-stack,
+  .number-cards,
+  .latent-variants {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    margin: 32px 0;
+    border-top: 1px solid var(--line);
+    border-left: 1px solid var(--line);
+  }
+
+  .formula-stack > div,
+  .number-cards article,
+  .latent-variants article {
+    padding: 26px;
+    border-right: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .formula-stack b {
+    display: block;
+    margin: 22px 0 14px;
+    font: 1.05rem/1.5 var(--mono);
+  }
+
+  .formula-stack p,
+  .number-cards p,
+  .latent-variants p {
+    margin-bottom: 0;
+    color: var(--ink-soft);
+    font-size: 0.86rem;
+  }
+
+  .number-cards {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+
+  .number-cards b {
+    display: block;
+    margin: 24px 0 12px;
+    font: 1.6rem/1 var(--mono);
+  }
+
+  .warning-note {
+    margin: 34px 0;
+    padding: 26px 30px;
+    border: 1px solid rgba(169, 86, 48, 0.4);
+    background: rgba(169, 86, 48, 0.055);
+  }
+
+  .warning-note b {
+    color: var(--copper);
+    font: 0.67rem/1 var(--mono);
+    letter-spacing: 0.08em;
+  }
+
+  .warning-note p {
+    margin-bottom: 0;
+  }
+
+  .wave-timeline {
+    margin: 34px 0;
+    border-top: 1px solid var(--line);
+  }
+
+  .wave-timeline article {
+    display: grid;
+    grid-template-columns: 44px 100px 1fr;
+    gap: 22px;
+    padding: 26px 0;
+    border-bottom: 1px solid var(--line);
+  }
+
+  .wave-index,
+  .wave-timeline time {
+    color: var(--ink-muted);
+    font: 0.62rem/1.5 var(--mono);
+  }
+
+  .wave-timeline h3 {
+    margin: 0 0 8px;
+    font-size: 1.16rem;
+  }
+
+  .wave-timeline article b {
+    color: var(--sage);
+    font: 0.65rem/1.5 var(--mono);
+  }
+
+  .wave-timeline article p {
+    margin: 9px 0;
+    color: var(--ink-soft);
+  }
+
+  .wave-timeline small {
+    color: var(--ink-muted);
+  }
+
+  .pipeline-visual {
+    display: grid;
+    grid-template-columns: 1fr auto 1fr auto 1fr auto 1fr auto 1fr;
+    margin: 36px 0;
+    border: 1px solid var(--line);
+  }
+
+  .pipeline-visual article {
+    min-height: 250px;
+    padding: 20px;
+  }
+
+  .pipeline-visual article > span,
+  .qb-flow article > span {
+    color: var(--copper);
+    font: 0.55rem/1 var(--mono);
+  }
+
+  .pipeline-visual article > b {
+    display: block;
+    margin: 22px 0;
+    font: 0.72rem/1 var(--mono);
+  }
+
+  .pipeline-visual p {
+    color: var(--ink-soft);
+    font-size: 0.8rem;
+    line-height: 1.65;
+  }
+
+  .pipeline-visual > i,
+  .deepseek-evolution > i,
+  .qb-flow > i {
+    display: grid;
+    place-items: center;
+    color: var(--copper);
+    font-style: normal;
+  }
+
+  .score-bars {
+    display: flex;
+    gap: 5px;
+    align-items: end;
+    height: 60px;
+  }
+
+  .score-bars i {
+    flex: 1;
+    height: 30%;
+    background: var(--sage);
+  }
+
+  .score-bars i:nth-child(2),
+  .score-bars i:nth-child(5) {
+    height: 90%;
+    background: var(--copper);
+  }
+
+  .topk {
+    display: flex;
+    gap: 6px;
+  }
+
+  .topk i {
+    padding: 10px;
+    color: var(--paper);
+    background: var(--navy);
+    font: normal 0.6rem/1 var(--mono);
+  }
+
+  .network-mini,
+  .gemm-mini,
+  .combine-mini {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 7px;
+  }
+
+  .network-mini i {
+    aspect-ratio: 1;
+    border: 1px solid var(--copper);
+    border-radius: 50%;
+  }
+
+  .gemm-mini i {
+    height: 20px;
+    background: var(--sage);
+  }
+
+  .combine-mini {
+    grid-template-columns: 1fr 1fr auto;
+    align-items: center;
+  }
+
+  .combine-mini i {
+    height: 34px;
+    border: 1px solid var(--line-strong);
+  }
+
+  .cost-ledger,
+  .stability-grid,
+  .stable-fixes,
+  .system-grid,
+  .evidence-ladder {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    margin: 34px 0;
+    border-top: 1px solid var(--line);
+    border-left: 1px solid var(--line);
+  }
+
+  .cost-ledger > div,
+  .stability-grid article,
+  .stable-fixes article,
+  .system-grid article,
+  .evidence-ladder article {
+    padding: 24px;
+    border-right: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .cost-ledger span {
+    color: var(--ink-muted);
+    font: 0.6rem/1 var(--mono);
+  }
+
+  .cost-ledger b {
+    display: block;
+    margin: 20px 0 10px;
+    font: 0.9rem/1.4 var(--mono);
+  }
+
+  .cost-ledger p,
+  .stability-grid p,
+  .stable-fixes p,
+  .stable-fixes small,
+  .evidence-ladder p {
+    color: var(--ink-soft);
+    font-size: 0.83rem;
+    line-height: 1.65;
+  }
+
+  .capacity-demo {
+    display: grid;
+    grid-template-columns: 0.85fr 1.15fr;
+    margin: 34px 0;
+    border: 1px solid var(--line);
+  }
+
+  .capacity-copy,
+  .capacity-bins {
+    padding: 30px;
+  }
+
+  .capacity-copy {
+    border-right: 1px solid var(--line);
+    background: var(--paper-shadow);
+  }
+
+  .capacity-copy h3 {
+    margin: 22px 0 14px;
+  }
+
+  .capacity-copy dl div {
+    display: flex;
+    justify-content: space-between;
+    padding: 11px 0;
+    border-top: 1px solid var(--line);
+  }
+
+  .capacity-copy dt,
+  .capacity-copy dd {
+    font: 0.62rem/1 var(--mono);
+  }
+
+  .capacity-copy dd {
+    margin: 0;
+  }
+
+  .capacity-bins article {
+    display: grid;
+    grid-template-columns: 32px 1fr 100px;
+    gap: 12px;
+    align-items: center;
+    margin: 16px 0;
+  }
+
+  .capacity-bins article > b,
+  .capacity-bins small {
+    font: 0.58rem/1 var(--mono);
+  }
+
+  .capacity-bins i {
+    position: relative;
+    height: 16px;
+    background:
+      linear-gradient(90deg, var(--sage) 0 var(--load), transparent var(--load)),
+      linear-gradient(90deg, transparent 0 var(--cap), var(--copper) var(--cap) calc(var(--cap) + 2px), transparent calc(var(--cap) + 2px));
+    border: 1px solid var(--line);
+  }
+
+  .stability-grid h3,
+  .stability-grid b,
+  .stable-fixes h3,
+  .system-grid h3,
+  .evidence-ladder h3 {
+    display: block;
+    margin: 22px 0 14px;
+    font-family: var(--serif);
+    font-size: 1.12rem;
+  }
+
+  .branch-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    margin: 34px 0;
+    border-top: 1px solid var(--line);
+    border-left: 1px solid var(--line);
+  }
+
+  .branch-grid article {
+    min-height: 230px;
+    padding: 26px;
+    border-right: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .branch-grid h3 {
+    margin: 24px 0 14px;
+  }
+
+  .branch-grid small {
+    color: var(--ink-muted);
+  }
+
+  .segmentation-visual,
+  .latent-visual {
+    display: grid;
+    grid-template-columns: 1fr auto 1fr;
+    align-items: stretch;
+    margin: 36px 0;
+    border: 1px solid var(--line);
+  }
+
+  .segmentation-visual > div,
+  .latent-visual > div {
+    padding: clamp(26px, 3vw, 38px);
+  }
+
+  .segmentation-visual > i {
+    display: grid;
+    place-items: center;
+    max-width: 90px;
+    padding: 12px;
+    border-inline: 1px solid var(--line);
+    color: var(--copper);
+    font: normal 0.55rem/1.5 var(--mono);
+    text-align: center;
+  }
+
+  .coarse-experts,
+  .fine-experts {
+    display: grid;
+    gap: 5px;
+    margin: 24px 0;
+  }
+
+  .coarse-experts {
+    grid-template-columns: repeat(4, 1fr);
+  }
+
+  .fine-experts {
+    grid-template-columns: repeat(8, 1fr);
+  }
+
+  .coarse-experts i,
+  .fine-experts i {
+    display: grid;
+    place-items: center;
+    aspect-ratio: 1;
+    border: 1px solid var(--line);
+    color: var(--ink-muted);
+    font: normal 0.52rem/1 var(--mono);
+  }
+
+  .coarse-experts i[data-on],
+  .fine-experts i[data-on] {
+    border-color: var(--copper);
+    background: var(--copper);
+    color: var(--paper);
+  }
+
+  .segmentation-visual > div > b {
+    font: 0.75rem/1.4 var(--mono);
+  }
+
+  .segmentation-visual p {
+    color: var(--ink-soft);
+    font-size: 0.84rem;
+  }
+
+  .shared-visual {
+    display: grid;
+    grid-template-columns: 0.7fr 1.3fr;
+    margin: 32px 0;
+    border: 1px solid var(--line);
+  }
+
+  .shared-visual > div {
+    padding: 30px;
+  }
+
+  .shared-path {
+    color: var(--paper);
+    background: var(--navy);
+  }
+
+  .shared-path b,
+  .router-path b {
+    display: block;
+    margin: 22px 0 14px;
+    font-family: var(--serif);
+    font-size: 1.4rem;
+  }
+
+  .shared-path p {
+    color: rgba(245, 242, 234, 0.72);
+  }
+
+  .router-path > div {
+    display: grid;
+    grid-template-columns: repeat(15, 1fr);
+    gap: 4px;
+    margin: 22px 0;
+  }
+
+  .router-path i {
+    aspect-ratio: 1;
+    border: 1px solid var(--line);
+  }
+
+  .router-path i[data-on] {
+    background: var(--sage);
+  }
+
+  .deepseek-evolution,
+  .qb-flow {
+    display: grid;
+    grid-template-columns: 1fr auto 1fr auto 1fr;
+    margin: 34px 0;
+    border: 1px solid var(--line);
+  }
+
+  .deepseek-evolution article,
+  .qb-flow article {
+    padding: 24px;
+  }
+
+  .deepseek-evolution time {
+    color: var(--copper);
+    font: 0.64rem/1 var(--mono);
+  }
+
+  .deepseek-evolution h3 {
+    margin: 22px 0 14px;
+  }
+
+  .deepseek-evolution p,
+  .deepseek-evolution small,
+  .qb-flow p {
+    color: var(--ink-soft);
+    font-size: 0.82rem;
+    line-height: 1.65;
+  }
+
+  .selection-weight {
+    display: grid;
+    grid-template-columns: 1fr auto 1fr;
+    align-items: stretch;
+    margin: 32px 0;
+  }
+
+  .selection-weight > div {
+    padding: 30px;
+    border: 1px solid var(--line);
+  }
+
+  .selection-weight > i {
+    display: grid;
+    place-items: center;
+    width: 72px;
+    color: var(--copper);
+    font: normal 1.5rem/1 var(--serif);
+  }
+
+  .selection-weight b {
+    display: block;
+    margin: 22px 0 12px;
+    font: 1.08rem/1.4 var(--mono);
+  }
+
+  .selection-weight p {
+    margin-bottom: 0;
+    color: var(--ink-soft);
+  }
+
+  .latent-visual {
+    grid-template-columns: 1fr 1fr;
+  }
+
+  .latent-visual > div:first-child {
+    border-right: 1px solid var(--line);
+  }
+
+  .latent-visual i,
+  .latent-visual b,
+  .latent-visual strong {
+    display: block;
+    margin: 14px 0;
+    padding: 12px;
+    font: normal 0.72rem/1.4 var(--mono);
+    text-align: center;
+  }
+
+  .latent-visual i {
+    border: 1px solid var(--line);
+  }
+
+  .latent-visual b {
+    color: var(--paper);
+    background: var(--navy);
+  }
+
+  .latent-visual strong {
+    color: var(--paper);
+    background: var(--sage);
+  }
+
+  .latent-visual p {
+    color: var(--ink-soft);
+    font-size: 0.83rem;
+  }
+
+  .latent-variants h3 {
+    margin: 20px 0 12px;
+  }
+
+  .k3-spec {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    margin: 34px 0;
+    border-top: 1px solid var(--line);
+    border-left: 1px solid var(--line);
+  }
+
+  .k3-spec article {
+    min-height: 130px;
+    padding: 24px;
+    border-right: 1px solid var(--line);
+    border-bottom: 1px solid var(--line);
+  }
+
+  .k3-spec b {
+    display: block;
+    margin-top: 24px;
+    font: 1.05rem/1.25 var(--mono);
+  }
+
+  .stable-fixes h3 {
+    min-height: 52px;
+  }
+
+  .stable-fixes small {
+    display: block;
+    margin-top: 12px;
+  }
+
+  .qb-flow {
+    grid-template-columns: 1fr auto 1fr auto 1fr auto 1fr;
+  }
+
+  .qb-flow article > b {
+    display: block;
+    margin: 20px 0 12px;
+    font: 0.72rem/1 var(--mono);
+  }
+
+  .wide-break :global(.moe-lab) {
+    width: min(1220px, calc(100vw - 80px));
+    margin-left: min(-110px, calc((1000px - 100vw) / 2));
+  }
+
+  .rank-balance {
+    display: grid;
+    grid-template-columns: 1fr auto 1fr;
+    align-items: stretch;
+    margin: 34px 0;
+    border: 1px solid var(--line);
+  }
+
+  .rank-balance > div {
+    padding: 28px;
+  }
+
+  .rank-balance > i {
+    display: grid;
+    place-items: center;
+    padding: 18px;
+    border-inline: 1px solid var(--line);
+    color: var(--copper);
+    font: normal 0.58rem/1.5 var(--mono);
+    text-align: center;
+  }
+
+  .rank-balance article {
+    display: grid;
+    grid-template-columns: 28px 1fr 54px;
+    gap: 10px;
+    align-items: center;
+    margin: 18px 0;
+  }
+
+  .rank-balance article b,
+  .rank-balance small {
+    font: 0.55rem/1 var(--mono);
+  }
+
+  .rank-balance article i {
+    height: 12px;
+    background: linear-gradient(90deg, var(--copper) 0 var(--rank), var(--paper-shadow) var(--rank));
+  }
+
+  .balanced-ranks article i {
+    background: var(--sage);
+  }
+
+  .system-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .evidence-ladder {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+
+  .evidence-ladder article > span {
+    display: grid;
+    place-items: center;
+    width: 32px;
+    height: 32px;
+    border: 1px solid var(--copper);
+    color: var(--copper);
+    font: 0.6rem/1 var(--mono);
+  }
+
+  .fact-split,
+  .source-footer {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    margin: 34px 0;
+    border: 1px solid var(--line);
+  }
+
+  .fact-split > div,
+  .source-footer > div {
+    padding: 26px;
+    border-right: 1px solid var(--line);
+  }
+
+  .fact-split > div:last-child,
+  .source-footer > div:last-child {
+    border-right: 0;
+  }
+
+  .fact-split p,
+  .source-footer p {
+    margin-bottom: 0;
+    color: var(--ink-soft);
+    font-size: 0.84rem;
+  }
+
+  .moe-chain .paper-row {
+    grid-template-columns: 90px 1.1fr 1.5fr;
+  }
+
+  .source-footer {
+    grid-template-columns: 1fr 1fr;
+  }
+
+  .source-footer code {
+    color: var(--ink);
+    font-size: 0.72rem;
+  }
+
+  .next-links {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 12px;
+    margin-top: 32px;
+  }
+
+  @media (max-width: 1180px) {
+    .wide-break :global(.moe-lab) {
+      width: 100%;
+      margin-left: 0;
+    }
+
+    .pipeline-visual {
+      grid-template-columns: repeat(5, 1fr);
+    }
+
+    .pipeline-visual > i {
+      display: none;
+    }
+  }
+
+  @media (max-width: 860px) {
+    .ledger-grid,
+    .number-cards,
+    .k3-spec,
+    .evidence-ladder {
+      grid-template-columns: repeat(2, 1fr);
+    }
+
+    .dense-moe-visual,
+    .capacity-demo,
+    .shared-visual,
+    .latent-visual,
+    .fact-split,
+    .source-footer {
+      grid-template-columns: 1fr;
+    }
+
+    .dense-side,
+    .capacity-copy,
+    .latent-visual > div:first-child,
+    .fact-split > div,
+    .source-footer > div {
+      border-right: 0;
+      border-bottom: 1px solid var(--line);
+    }
+
+    .pipeline-visual {
+      grid-template-columns: repeat(2, 1fr);
+    }
+
+    .pipeline-visual article {
+      min-height: 220px;
+      border-bottom: 1px solid var(--line);
+    }
+
+    .segmentation-visual,
+    .deepseek-evolution,
+    .qb-flow,
+    .rank-balance {
+      grid-template-columns: 1fr;
+    }
+
+    .segmentation-visual > i,
+    .deepseek-evolution > i,
+    .qb-flow > i,
+    .rank-balance > i {
+      max-width: none;
+      min-height: 46px;
+      border: 0;
+      border-block: 1px solid var(--line);
+    }
+
+    .selection-weight {
+      grid-template-columns: 1fr;
+    }
+
+    .selection-weight > i {
+      width: auto;
+      min-height: 54px;
+    }
+
+    .system-grid {
+      grid-template-columns: 1fr;
+    }
+  }
+
+  @media (max-width: 620px) {
+    .ledger-grid,
+    .formula-stack,
+    .number-cards,
+    .cost-ledger,
+    .stability-grid,
+    .branch-grid,
+    .latent-variants,
+    .k3-spec,
+    .stable-fixes,
+    .evidence-ladder {
+      grid-template-columns: 1fr;
+    }
+
+    .wave-timeline article {
+      grid-template-columns: 70px 1fr;
+    }
+
+    .wave-index {
+      display: none;
+    }
+
+    .pipeline-visual {
+      grid-template-columns: 1fr;
+    }
+
+    .capacity-bins article {
+      grid-template-columns: 28px 1fr;
+    }
+
+    .capacity-bins small {
+      grid-column: 2;
+    }
+
+    .router-path > div {
+      grid-template-columns: repeat(8, 1fr);
+    }
+
+    .moe-chain .paper-row {
+      grid-template-columns: 68px 1fr;
+    }
+  }
+</style>
diff --git a/src/pages/progress/index.astro b/src/pages/progress/index.astro
index 50fc259..9c8d0dd 100644
--- a/src/pages/progress/index.astro
+++ b/src/pages/progress/index.astro
@@ -7,11 +7,12 @@ const published = chapters.filter((chapter) => chapter.status === "published").l
 const researching = chapters.filter((chapter) => ["researching", "drafting"].includes(chapter.status)).length;
 
 const workstreams = [
-  { label: "研究框架与规范", value: 72, next: "给 125 篇索引补充逐篇精读层级" },
+  { label: "研究框架与规范", value: 76, next: "给 130 篇索引补充逐篇精读层级" },
   { label: "网站设计系统", value: 89, next: "打印样式与更多通用可视化组件" },
   { label: "Kimi K3 深读", value: 55, next: "扩写 scaling / infra 逐图笔记" },
   { label: "Transformer 基础", value: 52, next: "加入矩阵形状动画与手算练习" },
   { label: "DeepSeek 专题", value: 61, next: "GRPO 完整公式与训练轨迹推导" },
+  { label: "稀疏计算与 MoE", value: 74, next: "补充真实集群 traces 与专家特化案例" },
   { label: "长上下文专题", value: 72, next: "加入更多论文逐图笔记与真实模型配置对比" },
   { label: "引用与事实检查", value: 54, next: "自动化外链复查与来源等级扩展" },
   { label: "开源与部署", value: 100, next: "每轮保留不可变镜像、提交与回滚点" },
@@ -37,7 +38,7 @@ const workstreams = [
         <div><dt>OVERALL</dt><dd>专题平均 {average}%</dd></div>
         <div><dt>READABLE</dt><dd>{published} 个首版可读专题</dd></div>
         <div><dt>ACTIVE</dt><dd>{researching} 个研究/写作中</dd></div>
-        <div><dt>UPDATED</dt><dd>2026-07-28 22:47 CST</dd></div>
+        <div><dt>UPDATED</dt><dd>2026-07-28 23:24 CST</dd></div>
         <div><dt>MODE</dt><dd>持续迭代，不锁死版本</dd></div>
       </dl>
     </div>
@@ -47,7 +48,7 @@ const workstreams = [
     <div class="section-heading">
       <div>
         <p class="eyebrow"><span>01</span> WORKSTREAMS</p>
-        <h2>八条工作流同时推进，但不混淆“有页面”和“已核验”</h2>
+        <h2>九条工作流同时推进，但不混淆“有页面”和“已核验”</h2>
       </div>
       <p class="section-lead">
         内容首版优先打通全局脉络；随后每轮迭代选择一个专题推进到论文/工程层，并做独立事实复核。
@@ -84,10 +85,11 @@ const workstreams = [
       <article><span>✓</span><h3>K3 报告已结构化拆解</h3><p>47 页报告目录、151 条参考来源和架构/后训练/系统主线已经提取。</p></article>
       <article><span>✓</span><h3>16 专题知识图</h3><p>从语言模型基础到评测安全，包含先修依赖和三条贯穿案例。</p></article>
       <article><span>✓</span><h3>编辑式网站系统</h3><p>响应式导航、章节模板、侧栏、进度、论文链和证据提示组件。</p></article>
-      <article><span>✓</span><h3>四张原创交互图</h3><p>K3 三轴架构、Self-Attention Query、DeepSeek 谱系与长上下文成本实验室。</p></article>
-      <article><span>✓</span><h3>四篇首版长文</h3><p>K3 完整导读、Transformer 基础、DeepSeek 论文谱系与长上下文专题。</p></article>
+      <article><span>✓</span><h3>五张原创交互图</h3><p>K3 三轴架构、Self-Attention Query、DeepSeek 谱系、长上下文成本与 MoE 路由实验室。</p></article>
+      <article><span>✓</span><h3>五篇首版长文</h3><p>K3 导读、Transformer 基础、DeepSeek 谱系、长上下文与 MoE 专题。</p></article>
       <article><span>✓</span><h3>长上下文深度专题</h3><p>五张成本账、26 篇一手论文、10+ 机制图与 8 策略交互实验室。</p></article>
-      <article><span>✓</span><h3>125 篇关键论文索引</h3><p>覆盖 12 个专题，支持全文搜索、标签筛选与 Kimi/DeepSeek 聚光主线。</p></article>
+      <article><span>✓</span><h3>MoE 深度专题</h3><p>六张账、19 篇一手论文、DeepSeek/K3 主线与路由—容量—通信交互实验室。</p></article>
+      <article><span>✓</span><h3>130 篇关键论文索引</h3><p>覆盖 12 个专题，支持全文搜索、标签筛选与 Kimi/DeepSeek 聚光主线。</p></article>
       <article><span>✓</span><h3>公开仓库与自托管发布</h3><p>源码公开到 git.k1412.top，网站由不可变镜像、Compose Manager 与 HTTPS 交付。</p></article>
     </div>
   </section>
@@ -102,9 +104,9 @@ const workstreams = [
     </div>
     <div class="queue-table">
       <div class="head"><b>优先级</b><b>专题</b><b>本轮交付</b><b>完成闸门</b></div>
-      <div><span>P0</span><strong>稀疏计算与 MoE</strong><p>Switch → DeepSeekMoE → LatentMoE → Stable LatentMoE</p><em>路由模拟器 + 通信账本</em></div>
+      <div><span>P0</span><strong>推理模型与测试时扩展</strong><p>CoT → verifier → GRPO → R1 → k1.5 → K3 MOPD</p><em>奖励/预算交互图</em></div>
       <div><span>P1</span><strong>长上下文二轮深化</strong><p>真实模型配置 → 内核细节 → 长上下文评测与失败案例</p><em>配置比较器 + 逐图论文笔记</em></div>
-      <div><span>P1</span><strong>推理模型与测试时扩展</strong><p>CoT → verifier → GRPO → R1 → k1.5 → K3 MOPD</p><em>奖励/预算交互图</em></div>
+      <div><span>P1</span><strong>MoE 二轮深化</strong><p>真实负载 traces → 专家特化可解释性 → 共享专家语义</p><em>案例库 + 集群证据</em></div>
       <div><span>P1</span><strong>大规模训练系统</strong><p>ZeRO/Megatron → Expert/Context Parallel → DualPipe/MoonEP</p><em>显存与通信计算器</em></div>
       <div><span>P2</span><strong>原生多模态</strong><p>ViT/CLIP → connector VLM → Kimi-VL/MoonViT-V2</p><em>视觉 Token 流程图</em></div>
     </div>