@@ -33,6 +33,14 @@
 - CI 中检查包大小，超标则警告
 - 新功能不能使指标退化
 
+### 懒侧字节门禁（批 7 · 与首屏预算**互相独立**）
+
+- **口径**：懒加载 chunk（仅动态可达的 `.js`）单独判定 —— ① **族前缀清单等式**（每个懒侧 chunk 必须归属某个已登记族，**未归族即红**）② **逐族 gzip 上限** ③ **懒侧总 gzip 上限**（另加 chunk 数上限）。三条都只许降。
+- **判据键是族前缀**（`vendor-katex-*` 等）：Vite 的 chunk 名带内容 hash（不稳定）⇒ 键只能是去掉 8 位 hash 的名字加 `-`。
+- **基线来源**：`scripts/lazyBudget.json` —— 首次写入值 = 2026-09-13 实测 **36 chunk / 698.86 kB**（**冻结现状，不是目标值**；写乐观「预算值」会立刻红）。
+- **硬约束**：上表「页面包大小 (JS) < 200KB (gzip)」与懒侧预算是**两个独立读数** —— 懒侧判定不得影响首屏读数，两者也不得并成一个预算。
+- **工具**：`node scripts/check-bundle-budget.mjs --no-build`（人类可读，**分别**打印两个 pass）；加 `--json` 得平级的 `firstScreen` / `lazyBudget` 两栏。退出码 `1` = **任一**预算超标（首屏 / 懒侧）。
+
 ### 第二部分：测量与 Profiling
 
 **先测量，后优化。不要凭感觉优化。**
 
@@ -14,6 +14,10 @@
  *  3. gzip = `zlib.gzipSync(buf, { level: 6 })`；kB = **十进制 ÷1000**（vite 自己打印的口径，不是 KiB ÷1024）。
  *     冻结校准点：今天单一 chunk 构建下入口 chunk = **654,722 B = 654.72 kB**，与 vite 打印值逐字相等
  *     （计划者 / Task 1 / 控制方三方独立复现）。**若本脚本与此值不符，先怀疑脚本，绝不改数字。**
+ *  4. **懒侧（仅动态可达的 `.js`）有独立的第二个预算**（批 7 §C9.6 / §C10.4）：族前缀**清单等式** +
+ *     **逐族 gzip 上限** + **懒侧总 gzip 上限**（另加 chunk 数上限），基线 = `scripts/lazyBudget.json` 的
+ *     **实测冻结值**、只许降（写「预算值」式的乐观目标会立刻红）。判据键是**族前缀**（`vendor-katex-*`）而非
+ *     chunk 名（后者带内容 hash、不稳定）。🔴 首屏与懒侧是**两个独立读数**：懒侧判定不得影响首屏字段。
  *
  * 仪器陷阱（本批实测，勿改回）：
  *  - 静态边在产物里长 `from"./x-abc.js"`：**引号必须紧跟** `from` / `import`，故 `import(` 天然不匹配；
@@ -26,10 +30,13 @@
  *
  * 副作用：默认执行 `cd app && npm run build`（写 `app/dist/`）；`--no-build` 只读既有产物。
  *        `--self-test` 在 `os.tmpdir()` 下建夹具并在结束时删除，**不碰真实 `app/dist`**。
- * 用法：node scripts/check-bundle-budget.mjs [--no-build] [--budget <kB>] [--json] [--self-test] [--dist <目录>]
+ * 用法：node scripts/check-bundle-budget.mjs [--no-build] [--budget <kB>] [--json] [--self-test] [--dist <目录>] [--no-lazy]
  *        `--dist` 供自检夹具 / 备用产物目录使用（默认 `app/dist`），与构建互斥、须配 `--no-build`。
  *        `--json` 与默认构建同用会把 vite 输出混进 stdout；机器消费请配 `--no-build`。
- * 退出码：0 = 达标 · 1 = 超预算 · 2 = 构建失败 / 产物缺失 / 自检失败。
+ *        `--no-lazy` **只**给 `--dist` 的夹具用，且**不得**指向默认产物目录 ⇒ CI / husky / 收口读数都不带它，
+ *        **真实产物上懒侧门禁恒开**（它不是「可以关掉的守卫」）。
+ * 退出码：0 = **首屏与懒侧两个预算都达标** · 1 = **任一预算超标（首屏 / 懒侧）** ·
+ *        2 = 构建失败 / 产物缺失 / 自检失败。两个读数**互相独立**：懒侧判定**不得**影响首屏字段（批 7 §C11.5）。
  */
 import { readFileSync, existsSync, statSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join, resolve, dirname } from "node:path";
@@ -48,16 +55,58 @@ const opt = (f, dflt) => (argv.indexOf(f) >= 0 && argv[argv.indexOf(f) + 1] !==
 const NO_BUILD = has("--no-build");
 const AS_JSON = has("--json");
 const SELF_TEST = has("--self-test");
+const NO_LAZY = has("--no-lazy");
 const DIST = resolve(opt("--dist", join(APP, "dist")));
 const BUDGET_KB = Number(opt("--budget", "200"));
 const BUDGET_SOURCE = "docs/standards/performance.md:28";
+const LAZY_BUDGET = join(dirname(SELF), "lazyBudget.json");
 
 /** 全部失败路径的统一出口：**必须** exit 2（1 只留给「超预算」），并给出可执行的下一条命令。 */
 function fail(msg) {
   console.error(`❌ 首屏预算守卫：${msg}`);
   process.exit(2);
 }
 
+/**
+ * 懒侧基线（冻结值）：**缺失即失败**，绝不静默放行 —— 「读不到基线就当达标」是这类门禁最典型的失效形态。
+ */
+function loadLazyBudget(p) {
+  if (!existsSync(p) || !statSync(p).isFile()) fail(`找不到懒侧基线 ${rel(p)} —— 基线缺失时不得静默按「达标」放行。`);
+  const b = JSON.parse(readFileSync(p, "utf8"));
+  const ok = Array.isArray(b.families) && b.families.length > 0 && Number.isFinite(b.lazyTotalGzipBytesMax) && Number.isFinite(b.lazyChunkCountMax) && b.families.every((f) => typeof f.prefix === "string" && Number.isFinite(f.gzipBytesMax));
+  if (!ok) fail(`懒侧基线 ${rel(p)} 结构不完整（需要 families[{prefix,gzipBytesMax}] + lazyTotalGzipBytesMax + lazyChunkCountMax）。`);
+  return b;
+}
+
+/** 族前缀 = 去掉**8 位定长**内容 hash 的 chunk 名 + `-`。hash 字母表含 `-`（实测 `CaptureFloatPanel-CJ-lF7pj.js`）。 */
+const HASH_SUFFIX = /-[A-Za-z0-9_-]{8}\.js$/;
+const familyPrefixOf = (name) => (HASH_SUFFIX.test(name) ? name.replace(HASH_SUFFIX, "") + "-" : null);
+
+/**
+ * 懒侧四条判据：① **清单等式**（每个懒侧 chunk 都必须归属某个已登记族 —— 没有 `others` 白名单，就是要让
+ * 产物演进**红**而不是静默通过）② **逐族 gzip 上限** ③ **总 gzip 上限** ④ chunk 数上限。
+ * 每条**各产生一条具名 reason**（C9.6 第 3 条：必须红在具名断言上）。
+ */
+function judgeLazy(r, base) {
+  const fams = new Map(base.families.map((f) => [f.prefix, { prefix: f.prefix, gzipBytesMax: f.gzipBytesMax, chunks: [], gzipBytes: 0 }]));
+  const unlisted = [];
+  for (const c of r.lazy) {
+    const f = fams.get(familyPrefixOf(c.name));
+    if (!f) { unlisted.push(c.name); continue; }
+    f.chunks.push(c.name);
+    f.gzipBytes += c.gzipBytes;
+  }
+  const families = [...fams.values()];
+  const totalBytes = r.lazy.reduce((a, c) => a + c.gzipBytes, 0);
+  const overFamilies = families.filter((f) => f.gzipBytes > f.gzipBytesMax);
+  const reasons = [];
+  if (unlisted.length) reasons.push(`① 族前缀清单等式：未归族 ${unlisted.length} 个（${unlisted.join(", ")}）`);
+  for (const f of overFamilies) reasons.push(`② 逐族上限：${f.prefix} gzip ${fmtB(f.gzipBytes)} B > 上限 ${fmtB(f.gzipBytesMax)} B`);
+  if (totalBytes > base.lazyTotalGzipBytesMax) reasons.push(`③ 懒侧总 gzip：${fmtB(totalBytes)} B > 上限 ${fmtB(base.lazyTotalGzipBytesMax)} B`);
+  if (r.lazy.length > base.lazyChunkCountMax) reasons.push(`④ 懒侧 chunk 数：${r.lazy.length} > 上限 ${base.lazyChunkCountMax}`);
+  return { families, unlisted, overFamilies, totalBytes, totalMax: base.lazyTotalGzipBytesMax, count: r.lazy.length, countMax: base.lazyChunkCountMax, reasons, pass: reasons.length === 0 };
+}
+
 /** 参考项：HTML 用 modulepreload 声明但静态闭包没覆盖的 .js —— 值得人看一眼，不影响判定。 */
 function preloadUncovered(dist, eager) {
   const html = readFileSync(join(dist, "index.html"), "utf8");
@@ -66,7 +115,7 @@ function preloadUncovered(dist, eager) {
   return [...new Set(tags.filter((n) => n.endsWith(".js") && !eager.has(n)))];
 }
 
-function printHuman(r, pass) {
+function printHuman(r, pass, lazy) {
   console.log(`首屏预算守卫 · 产物 ${rel(r.dist)}`);
   console.log(`  单位：kB = 字节 ÷ 1000（十进制，vite 口径；勿与 ÷1024 的 KiB 混用，混用会产生假 Δ）· gzip = zlib level 6`);
   console.log(`  口径：module 入口 + 只沿静态 ESM import 可达的 .js，动态 import 不计 · 预算 ${BUDGET_KB} kB gzip（来源 ${BUDGET_SOURCE}）`);
@@ -75,9 +124,13 @@ function printHuman(r, pass) {
     console.log(`  ${name.padEnd(34)} ${fmtB(c.bytes).padStart(10)} B  →  gzip ${fmtB(c.gzip).padStart(9)} B = ${kB(c.gzip).padStart(8)} kB`);
   }
   console.log(`  首屏 JS 合计：原始 ${fmtB(r.rawBytes)} B · gzip ${fmtB(r.eagerBytes)} B = ${kB(r.eagerBytes)} kB`);
-  console.log(`  ⇒ ${pass ? "✅ 达标" : "❌ 超标"}：${pass ? "余量" : "超出"} ${kB(Math.abs(BUDGET_KB * 1000 - r.eagerBytes))} kB${pass ? "" : `（${(r.eagerBytes / 1000 / BUDGET_KB).toFixed(2)}× 预算）`}`);
+  console.log(`  ⇒ 首屏预算 ${pass ? "✅ 达标" : "❌ 超标"}：${pass ? "余量" : "超出"} ${kB(Math.abs(BUDGET_KB * 1000 - r.eagerBytes))} kB${pass ? "" : `（${(r.eagerBytes / 1000 / BUDGET_KB).toFixed(2)}× 预算）`}`);
   const lazyBytes = r.lazy.reduce((a, c) => a + c.gzipBytes, 0);
-  console.log(`懒加载 chunk（仅动态可达，不计入预算）：${r.lazy.length} 个 · gzip ${fmtB(lazyBytes)} B = ${kB(lazyBytes)} kB`);
+  console.log(`懒加载 chunk（仅动态可达，独立于首屏预算）：${r.lazy.length} 个 · gzip ${fmtB(lazyBytes)} B = ${kB(lazyBytes)} kB`);
+  if (lazy) {
+    console.log(`  懒侧口径：族前缀清单等式 + 逐族 gzip 上限 + 懒侧总 gzip 上限 · 基线 ${rel(LAZY_BUDGET)}（实测冻结值，只许降）· 未归族与超上限都红`);
+    console.log(`  ⇒ 懒侧预算 ${lazy.pass ? "✅ 达标" : "❌ 超标"}：gzip ${kB(lazy.totalBytes)} kB / 上限 ${kB(lazy.totalMax)} kB · chunk ${lazy.count} 个 / 上限 ${lazy.countMax} 个 · 未归族 ${lazy.unlisted.length} 个 · 超上限族 ${lazy.overFamilies.length} 个`);
+  } else console.log(`  ⇒ 懒侧预算 ⏭ 未判（--no-lazy，仅供 --dist 夹具；真实产物上恒判）`);
   console.log(`不计入预算但须报告（CSS / 字体）：index.html ${fmtB(r.htmlBytes)} B = ${kB(r.htmlBytes)} kB · gzip ${kB(r.htmlGzip)} kB`);
   const byExt = new Map();
   for (const a of r.excluded) {
@@ -90,7 +143,7 @@ function printHuman(r, pass) {
   }
 }
 
-const jsonOf = (r, pass) => ({
+const jsonOf = (r, pass, lazy) => ({
   dist: rel(r.dist),
   budgetKb: BUDGET_KB,
   budgetSource: BUDGET_SOURCE,
@@ -99,20 +152,38 @@ const jsonOf = (r, pass) => ({
     count: r.eager.size,
     chunks: [...r.eager].map(([name, c]) => ({ name, bytes: c.bytes, gzipBytes: c.gzip, gzipKb: Number(kB(c.gzip)) })),
     totalBytes: r.eagerBytes,
-    totalKb: Number(kB(r.eagerBytes)),
+    totalKb: Number(kB(r.eagerBytes)), pass,
   },
   lazy: { count: r.lazy.length, chunks: r.lazy, totalBytes: r.lazy.reduce((a, c) => a + c.gzipBytes, 0) },
+  lazyBudget: lazy
+    ? {
+        pass: lazy.pass,
+        baseline: rel(LAZY_BUDGET),
+        count: lazy.count,
+        countMax: lazy.countMax,
+        totalBytes: lazy.totalBytes,
+        totalKb: Number(kB(lazy.totalBytes)),
+        totalMaxBytes: lazy.totalMax,
+        unlisted: lazy.unlisted,
+        fails: lazy.reasons,
+        families: lazy.families.map((f) => ({ prefix: f.prefix, chunkCount: f.chunks.length, gzipBytes: f.gzipBytes, gzipBytesMax: f.gzipBytesMax, pass: f.gzipBytes <= f.gzipBytesMax })),
+      }
+    : { pass: true, skipped: "--no-lazy（仅供 --dist 夹具；真实产物上恒判）" },
   excludedFromBudget: { indexHtml: { bytes: r.htmlBytes, gzipBytes: r.htmlGzip }, assets: r.excluded },
   pass,
 });
 
-/** 报表 + 退出码：0 = 达标 · 1 = 超预算。超预算时把差额与倍数一并说清（可执行、不含糊）。 */
+/**
+ * 报表 + 退出码：0 = **两个预算都达标** · 1 = **任一超标**（首屏 / 懒侧，各自点名）。
+ * 🔴 顶层 `pass` 是**首屏** pass（既有消费方的兼容字段）；懒侧见 `lazyBudget.pass`。
+ */
 function finish(r) {
   const pass = r.eagerBytes / 1000 < BUDGET_KB;
+  const lazy = NO_LAZY ? null : judgeLazy(r, loadLazyBudget(LAZY_BUDGET));
   if (AS_JSON) {
-    console.log(JSON.stringify(jsonOf(r, pass), null, 2));
+    console.log(JSON.stringify(jsonOf(r, pass, lazy), null, 2));
   } else {
-    printHuman(r, pass);
+    printHuman(r, pass, lazy);
     const uncovered = preloadUncovered(r.dist, r.eager);
     if (uncovered.length) console.log(`ℹ️ modulepreload 声明但静态闭包未覆盖 ${uncovered.length} 个：${uncovered.join(", ")}（参考项，不影响判定）`);
   }
@@ -122,7 +193,8 @@ function finish(r) {
         `（${(r.eagerBytes / 1000 / BUDGET_KB).toFixed(2)}×）—— 退出码 1。降首屏只能靠 import() 切断静态边；manualChunks 只切文件、一字节不降。`,
     );
   }
-  process.exit(pass ? 0 : 1);
+  if (lazy && !lazy.pass) console.error(`❌ 懒侧 gzip 预算超标（退出码 1）—— 具名断言：${lazy.reasons.join("；")}。基线 ${rel(LAZY_BUDGET)} 只许降（§C9.6 第 2 条）。`);
+  process.exit(pass && (!lazy || lazy.pass) ? 0 : 1);
 }
 
 /**
@@ -166,7 +238,8 @@ function selfTest() {
     for (const d of ["empty", "noscript/assets", "partial/assets"]) mkdirSync(join(dir, d), { recursive: true });
     w("noscript/index.html", `<!doctype html><html><body></body></html>`);
     w("partial/index.html", `<script type="module" src="/assets/gone.js"></script>`);
-    const child = (...args) => spawnSync(process.execPath, [SELF, "--no-build", "--dist", ...args], { encoding: "utf8" });
+    // 夹具产物是人工造的（`dyn-only.js` 之类不可能命中真实基线）⇒ 夹具子进程显式关懒侧判定，本自检继续只证**首屏**口径与退出码契约 ⇒ 读数逐字不变。⚠️ `--no-lazy` 必须排在**所有带值旗标之后**（`opt()` 取旗标的下一个 argv 元素；紧跟 `--dist` 会把它吃掉）。
+    const child = (...args) => spawnSync(process.execPath, [SELF, "--no-build", "--dist", ...args, "--no-lazy"], { encoding: "utf8" });
     const cases = [
       ["dist 不存在", 2, [join(dir, "nope")]],
       ["空 dist（无 index.html）", 2, [join(dir, "empty")]],
@@ -207,6 +280,9 @@ if (!Number.isFinite(BUDGET_KB) || BUDGET_KB <= 0) {
   fail(`--budget 需要正数（实得 "${opt("--budget", "")}"）—— 预算解析失败时绝不能静默按「超标」处理。`);
 }
 if (has("--dist") && !NO_BUILD) fail(`--dist 与构建互斥：--dist 用于既有产物或自检夹具，请配 --no-build。`);
+// `--no-lazy` 是**夹具通道**而不是「守卫开关」：只许与 `--dist` 同用，且不得指向默认产物目录
+// ⇒ 真实产物（CI / husky / 收口读数）上懒侧门禁**恒开**。
+if (NO_LAZY && (!has("--dist") || DIST === resolve(join(APP, "dist")))) fail(`--no-lazy 只许配 --dist 且不得指向默认产物目录 ${rel(join(APP, "dist"))} —— 真实产物上懒侧门禁恒判。`);
 // 度量已搬进 `./lib/bundleMeasure.mjs`：那边的 `fail()` **只抛** `BudgetError`（度量模块不得持有进程
 // 出口），这里把它桥回本件的统一出口（`console.error` + `exit 2`，文案逐字不变）。用**专属类型**是为了
 // 让其余异常继续原样上抛 —— 拆前它们就是未捕获栈 + exit 1，无差别转 exit 2 才是真的行为变化。
 
@@ -0,0 +1,153 @@
+{
+  "generatedFrom": "node scripts/check-bundle-budget.mjs --no-build --json（2026-09-13 实测；批 7 T9）",
+  "unit": "gzip = zlib.gzipSync level 6 · 族前缀 = 去掉 8 位内容 hash 的 chunk 名 + '-'（chunk 名带内容 hash，不稳定，不能当键）",
+  "semantics": "全部字段 = 当次实测的**冻结值**，只许降（批 7 §C9.6 第 2 条 / §C10.4）；写乐观「预算值」会立刻红",
+  "lazyChunkCountMax": 36,
+  "lazyTotalGzipBytesMax": 698859,
+  "families": [
+    {
+      "prefix": "ActionPage-",
+      "gzipBytesMax": 8191
+    },
+    {
+      "prefix": "AiConversationDock-",
+      "gzipBytesMax": 2807
+    },
+    {
+      "prefix": "CaptureFloatPanel-",
+      "gzipBytesMax": 4538
+    },
+    {
+      "prefix": "CaptureOverlayPanel-",
+      "gzipBytesMax": 1402
+    },
+    {
+      "prefix": "ChatPage-",
+      "gzipBytesMax": 11382
+    },
+    {
+      "prefix": "ConfirmDialog-",
+      "gzipBytesMax": 765
+    },
+    {
+      "prefix": "GoalsPage-",
+      "gzipBytesMax": 12349
+    },
+    {
+      "prefix": "KnowledgePage-",
+      "gzipBytesMax": 27621
+    },
+    {
+      "prefix": "NoteCardFlowView-",
+      "gzipBytesMax": 787
+    },
+    {
+      "prefix": "NoteMarkdown-",
+      "gzipBytesMax": 2948
+    },
+    {
+      "prefix": "NotesPage-",
+      "gzipBytesMax": 47047
+    },
+    {
+      "prefix": "RefineLaunchDialog-",
+      "gzipBytesMax": 7184
+    },
+    {
+      "prefix": "RefineStrategyPicker-",
+      "gzipBytesMax": 2710
+    },
+    {
+      "prefix": "ReviewPage-",
+      "gzipBytesMax": 6815
+    },
+    {
+      "prefix": "SessionCardFlowView-",
+      "gzipBytesMax": 767
+    },
+    {
+      "prefix": "SessionNotePreview-",
+      "gzipBytesMax": 4899
+    },
+    {
+      "prefix": "SessionProofView-",
+      "gzipBytesMax": 1069
+    },
+    {
+      "prefix": "SessionScreenCard-",
+      "gzipBytesMax": 255
+    },
+    {
+      "prefix": "SessionTriTrackView-",
+      "gzipBytesMax": 4325
+    },
+    {
+      "prefix": "SessionsPage-",
+      "gzipBytesMax": 21012
+    },
+    {
+      "prefix": "SettingsPage-",
+      "gzipBytesMax": 17762
+    },
+    {
+      "prefix": "TaskConversationView-",
+      "gzipBytesMax": 2923
+    },
+    {
+      "prefix": "ViewSwitcher-",
+      "gzipBytesMax": 562
+    },
+    {
+      "prefix": "colorPalette-",
+      "gzipBytesMax": 947
+    },
+    {
+      "prefix": "controls-",
+      "gzipBytesMax": 400
+    },
+    {
+      "prefix": "engine-",
+      "gzipBytesMax": 200
+    },
+    {
+      "prefix": "entityLabel-",
+      "gzipBytesMax": 250
+    },
+    {
+      "prefix": "registry-",
+      "gzipBytesMax": 1966
+    },
+    {
+      "prefix": "shift-",
+      "gzipBytesMax": 212
+    },
+    {
+      "prefix": "useColumnFlip-",
+      "gzipBytesMax": 817
+    },
+    {
+      "prefix": "useDbRefresh-",
+      "gzipBytesMax": 383
+    },
+    {
+      "prefix": "vendor-canvas-",
+      "gzipBytesMax": 58784
+    },
+    {
+      "prefix": "vendor-editor-",
+      "gzipBytesMax": 208585
+    },
+    {
+      "prefix": "vendor-gsap-",
+      "gzipBytesMax": 41161
+    },
+    {
+      "prefix": "vendor-katex-",
+      "gzipBytesMax": 144412
+    },
+    {
+      "prefix": "vendor-md-",
+      "gzipBytesMax": 50622
+    }
+  ]
+}