dsh-metaphysics 0.59.0 → 0.59.1

package//345/221/275/347/220/206/346/216/222/347/233/230.html

@@ -340,13 +340,14 @@ h3::after{content:"";flex:1;height:1px;background:linear-gradient(90deg,var(--li
   .pp,.mp-it,.pp *,.mp-it *{-webkit-print-color-adjust:exact;print-color-adjust:exact}
   a[href]::after{content:""}
 }
+.chk{display:inline-flex;align-items:center;gap:6px;font-size:13px;cursor:pointer}
 </style>
 </head>
 <body>
 <div class="wrap">
   <header>
     <div class="brand-row">
-      <div class="brand"><span class="seal" aria-hidden="true">命</span><span class="brand-txt">命理排盘<span class="ver">v0.59.0</span><small>八字 · 紫微 · 六爻 · 梅花 · 六壬 · 奇门 · 合盘 · 塔罗　全部在本机计算</small></span></div>
+      <div class="brand"><span class="seal" aria-hidden="true">命</span><span class="brand-txt">命理排盘<span class="ver">v0.59.1</span><small>八字 · 紫微 · 六爻 · 梅花 · 六壬 · 奇门 · 合盘 · 塔罗　全部在本机计算</small></span></div>
       <div class="view-switch">
         <span class="hint">熟练了可以换回平铺</span>
         <span class="seg" role="group" aria-label="首屏样式">
@@ -430,6 +431,9 @@ h3::after{content:"";flex:1;height:1px;background:linear-gradient(90deg,var(--li
          切到六爻/梅花/六壬等起卦类 tab 时，web-ui.js 会自动把这两个框换成你的本机当前时刻。 -->
     <label class="field" id="for-date"><span id="lbl-date">出生日期（公历）</span><input id="date" type="date" value="1990-05-12"></label>
     <label class="field" id="for-time"><span id="lbl-time">出生时刻</span><input id="time" type="time" value="14:30"></label>
+    <!-- 时辰未知：只在八字/人生K线出现。勾上＝不排时柱、起运降到按日，结果首行固定提示。
+         紫微/合盘不提供这个勾选——它们没有时支就整盘不成立，给了勾选等于诱导出一个假盘。 -->
+    <label class="chk" id="for-hourunknown" style="display:none"><input type="checkbox" id="hourunknown"> 时辰未知</label>
     <label class="field" id="for-gender">性别
       <select id="gender"><option value="female">女</option><option value="male">男</option></select>
     </label>
@@ -630,7 +634,7 @@ h3::after{content:"";flex:1;height:1px;background:linear-gradient(90deg,var(--li
     <h3>对拍：把典籍当期望值</h3>
     <ul><li>六爻：京房八宫卦序与世应，64 卦全表；旬空六旬表</li><li>六壬：日干寄宫、中气换将；紫微：纳音定五行局、紫微天府相照</li><li>卦例：《增删卜易》9 条 +《卜筮正宗》128 条（93 成对 + 35 静卦），核本变卦 / 动爻数 / 卦宫 / 缺爻 / 旬空</li><li>奇门：20 个时辰 × 9 宫，核四柱 / 局数 / 值符 / 值使 / 星门神 / 天盘干</li></ul>
     <h3>工程验证</h3>
-    <ul><li>测试：134 个测试文件 / 6225 条断言；七道闸（回归 · 断言基线 · 测试可失败自检 · HTML 注入面 · 工程约定 · 产物宿主形态 · 随机扫射）</li><li>可复现：seed / asOf 显式；同一输入同一输出</li><li>口径：晚子时、真太阳时、奇门三流派、闰月归月都可切换，并有字段级差异对照</li></ul>
+    <ul><li>测试：138 个测试文件 / 6737 条断言；七道闸（回归 · 断言基线 · 测试可失败自检 · HTML 注入面 · 工程约定 · 产物宿主形态 · 随机扫射）</li><li>可复现：seed / asOf 显式；同一输入同一输出</li><li>口径：晚子时、真太阳时、奇门三流派、闰月归月都可切换，并有字段级差异对照</li></ul>
     <h3>已知边界（不猜）</h3>
     <ul><li>六爻应期（具体哪天应验）不做；卦例只录动爻个数，不录爻位</li><li>财富/健康只给结构判断与档位，不给金额区间、不作诊断</li><li>紫微飞星已做「单一支化逐宫追到成环」与「三方四正 16 条按落宫归堆」，但都未叠大限流年四化、不折吉凶；八字交运日已能算到日/时，但未与第三方排盘案例批量对拍</li></ul>
     <p class="note">内容用于传统文化学习与自我探索，不构成医疗、投资、法律或人事决策依据。</p>
@@ -688,6 +692,9 @@ const IGNORE_KEYS = new Set([
   'handle', 'handleError',
   // 一句话改参的回显：换口径时它必然不同（等于另一次请求），不是盘面差异
   'revision',
+  // 顶部「人话总结」是从盘面派生出来的叙述，不是盘面本身：换一档口径，
+  // 它必然跟着改写（句子会重排），但要看的是星位、日柱这些有没有动。
+  'brief', 'briefError',
 ]);
 
 const isObject = (v) => v !== null && typeof v === 'object';
@@ -4519,1294 +4526,1355 @@ return { CLASSIC_BOOKS, CLASSICS, classicOf, suiyunClassicOf, classicsFor, class
 })();
 
 __mods.geju = (function () {
-// 八字格局、用神与行运评分
-//
-// 定位：在 bazi.js 算出四柱、五行、旺衰之后，给出
-//   1) 格局（月令格 + 特殊格 + 常见组合）；
-//   2) 用神 / 喜忌（调候优先 + 扶抑校验；气候平和时仍以扶抑为主）；
-//   3) 大运、流年的吉凶倾向评分（含调候修正项）。
-// 取舍：格局派别差异极大，这里只给「规则可复核」的判定，evidence 写明依据；
-// 调候由 tiaohou.js 独立判定，与扶抑冲突时显式裁决并写明理由，不静默取用。
-
-const { judgeClimate, arbitrate } = (__mods.tiaohou || {});
-const { qtOf } = (__mods.qiongtong || {});
-const { SANHE_GROUPS, sanheGroupOf } = (__mods.sanhe || {});
-
-const STEMS = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
-const BRANCHES = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];
-
-const STEM_ELEMENT = {
-  甲: '木', 乙: '木', 丙: '火', 丁: '火', 戊: '土',
-  己: '土', 庚: '金', 辛: '金', 壬: '水', 癸: '水',
-};
-const BRANCH_ELEMENT = {
-  子: '水', 丑: '土', 寅: '木', 卯: '木', 辰: '土', 巳: '火',
-  午: '火', 未: '土', 申: '金', 酉: '金', 戌: '土', 亥: '水',
-};
-const GENERATES = { 木: '火', 火: '土', 土: '金', 金: '水', 水: '木' };
-const OVERCOMES = { 木: '土', 土: '水', 水: '火', 火: '金', 金: '木' };
-const HIDDEN = {
-  子: ['癸'], 丑: ['己', '癸', '辛'], 寅: ['甲', '丙', '戊'], 卯: ['乙'],
-  辰: ['戊', '乙', '癸'], 巳: ['丙', '戊', '庚'], 午: ['丁', '己'], 未: ['己', '丁', '乙'],
-  申: ['庚', '壬', '戊'], 酉: ['辛'], 戌: ['戊', '辛', '丁'], 亥: ['壬', '甲'],
-};
-const HIDDEN_W = [1, 0.5, 0.3];
-
-const LUSHEN_BRANCH = { 甲: '寅', 乙: '卯', 丙: '巳', 丁: '午', 戊: '巳', 己: '午', 庚: '申', 辛: '酉', 壬: '亥', 癸: '子' };
-const YANGREN_BRANCH = { 甲: '卯', 乙: '辰', 丙: '午', 丁: '未', 戊: '午', 己: '未', 庚: '酉', 辛: '戌', 壬: '子', 癸: '丑' };
-const STEM_HE = { 甲己: '土', 乙庚: '金', 丙辛: '水', 丁壬: '木', 戊癸: '火' };
-
-const isYangStem = (s) => STEMS.indexOf(s) % 2 === 0;
-const ELEMENTS = ['木', '火', '土', '金', '水'];
-
-/** 十神：以日干为我（与 bazi.js 同规则） */
-function tenGod(dayStem, otherStem) {
-  const me = STEM_ELEMENT[dayStem];
-  const it = STEM_ELEMENT[otherStem];
-  const same = isYangStem(dayStem) === isYangStem(otherStem);
-  if (me === it) return same ? '比肩' : '劫财';
-  if (GENERATES[me] === it) return same ? '食神' : '伤官';
-  if (OVERCOMES[me] === it) return same ? '偏财' : '正财';
-  if (OVERCOMES[it] === me) return same ? '七杀' : '正官';
-  if (GENERATES[it] === me) return same ? '偏印' : '正印';
-  return '?';
-}
-
-const godGroups = {
-  比劫: ['比肩', '劫财'],
-  食伤: ['食神', '伤官'],
-  财: ['正财', '偏财'],
-  官杀: ['正官', '七杀'],
-  印: ['正印', '偏印'],
-};
-
-/** 全局十神权重：四柱天干 1.0，地支藏干按本气 1 / 中气 0.5 / 余气 0.3 */
-function godStats(pillars, dayStem) {
-  const total = { 比劫: 0, 食伤: 0, 财: 0, 官杀: 0, 印: 0 };
-  const byGod = { 比肩: 0, 劫财: 0, 食神: 0, 伤官: 0, 正财: 0, 偏财: 0, 正官: 0, 七杀: 0, 正印: 0, 偏印: 0 };
-  const add = (stem, w) => {
-    const god = tenGod(dayStem, stem);
-    const g = Object.keys(godGroups).find((k) => godGroups[k].includes(god));
-    if (g) total[g] += w;
-    if (byGod[god] !== undefined) byGod[god] += w;
-  };
-  for (const key of ['year', 'month', 'day', 'hour']) {
-    add(pillars[key].stem, key === 'day' ? 0.6 : 1);
-    (HIDDEN[pillars[key].branch] || []).forEach((h, i) => add(h, HIDDEN_W[i] ?? 0.1));
-  }
-  for (const k of Object.keys(total)) total[k] = Math.round(total[k] * 10) / 10;
-  for (const k of Object.keys(byGod)) byGod[k] = Math.round(byGod[k] * 10) / 10;
-  return { groups: total, byGod };
-}
-
-/** 用神所属五行：生我 / 同我 / 我生 / 我克 / 克我 */
-function elementRoles(dayStem) {
-  const me = STEM_ELEMENT[dayStem];
-  const inMe = ELEMENTS.find((e) => GENERATES[e] === me);
-  const guan = ELEMENTS.find((e) => OVERCOMES[e] === me);
-  return { me, inMe, shi: GENERATES[me], cai: OVERCOMES[me], guan };
-}
-
-// ── 月令格 ───────────────────────────────────────────────────
-
-// 四墓（杂气）月：辰戌丑未所藏多、用神不一，取用先看透干，再看会支。
-// 会支只认三合局——子平真诠十六「逢申与子会局」的例子即三合，三会方与兼透兼用仍不纳入。
-const ZA_MONTHS = ['辰', '未', '戌', '丑'];
-
-function huiCandidate(pillars, monthBranch, cands) {
-  if (!ZA_MONTHS.includes(monthBranch)) return null;
-  const group = sanheGroupOf(monthBranch);
-  if (!group) return null;
-  const others = ['year', 'day', 'hour'];
-  const need = group.branches.filter((b) => b !== monthBranch);
-  if (!need.every((b) => others.some((k) => pillars[k].branch === b))) return null;
-  const cand = cands.find((c) => STEM_ELEMENT[c.stem] === group.element);
-  if (!cand) return null;
-  const where = others
-    .filter((k) => need.includes(pillars[k].branch))
-    .map((k) => `${({ year: '年', day: '日', hour: '时' })[k]}支${pillars[k].branch}`);
-  return { ...cand, group, where };
-}
-
-function monthPattern(pillars, dayStem, monthBranch) {
-  const hidden = HIDDEN[monthBranch] || [];
-  const cands = hidden.map((stem, i) => ({
-    stem,
-    god: tenGod(dayStem, stem),
-    pos: ['本气', '中气', '余气'][i],
-    w: HIDDEN_W[i] ?? 0.1,
-  }));
-  const others = ['year', 'month', 'hour'];
-  const exposedKey = others.find((k) => cands.some((c) => c.stem === pillars[k].stem));
-  const base = cands[0];
-  const hui = exposedKey ? null : huiCandidate(pillars, monthBranch, cands);
-  const use = exposedKey ? cands.find((c) => c.stem === pillars[exposedKey].stem) : (hui || base);
-  const usedBy = exposedKey ? '透干' : (hui ? '会支' : '本气');
-  const exposedPos = exposedKey ? { year: '年', month: '月', hour: '时' }[exposedKey] : null;
-
-  // 建禄只认日干的禄位；戊土辰月、己土未月这类「本气比肩但不在禄位」的杂气月不再冒称建禄
-  if (base.god === '比肩' && LUSHEN_BRANCH[dayStem] === monthBranch) {
-    return {
-      name: '建禄格',
-      kind: '月令格',
-      evidence: `月令${monthBranch}为日干${dayStem}之禄（本气${base.stem}比肩），身坐禄地`,
-    };
-  }
-  if (base.god === '劫财') {
-    if (YANGREN_BRANCH[dayStem] === monthBranch) {
-      return {
-        name: isYangStem(dayStem) ? '阳刃格' : '月刃格',
-        kind: '月令格',
-        evidence: `月令${monthBranch}为日干${dayStem}之刃（本气${base.stem}劫财）${isYangStem(dayStem) ? '' : '，阴干统称月刃'}`,
-      };
-    }
-    return { name: '月劫格', kind: '月令格', evidence: `月令${monthBranch}本气${base.stem}为劫财` };
-  }
-  if (usedBy === '本气' && base.god === '比肩') {
-    return {
-      name: '比肩格',
-      kind: '月令格',
-      evidence: `月令${monthBranch}藏${hidden.join('')}，本气${base.stem}为比肩，但${dayStem}禄在${LUSHEN_BRANCH[dayStem]}、不在${monthBranch}，属杂气月比肩当权`,
-    };
-  }
-  // 子平十六：「透乙则用月劫」——杂气月由透干或会支取到劫财时，仍作月劫论
-  if (usedBy !== '本气' && use.god === '劫财') {
-    const via = exposedKey ? `透于${exposedPos}干` : `${hui.where.join('、')}会成${hui.group.element}局`;
-    return {
-      name: '月劫格',
-      kind: '月令格',
-      evidence: `月令${monthBranch}藏${hidden.join('')}，${use.pos}${use.stem}（劫财）${via}，劫财为用，作月劫论`,
-    };
-  }
-  const name = `${use.god}格`;
-  let ex;
-  if (exposedKey) {
-    ex = `月令${monthBranch}藏${hidden.join('')}，${use.pos}${use.stem}（${use.god}）透于${exposedPos}干`;
-  } else if (hui) {
-    ex = `月令${monthBranch}藏${hidden.join('')}，本气${base.stem}（${base.god}）未透干，而${hui.where.join('、')}会成${hui.group.element}局，取${use.pos}${use.stem}（${use.god}）为用`;
-  } else {
-    ex = `月令${monthBranch}藏${hidden.join('')}，本气${base.stem}（${base.god}）未透干，以月令本气取格`;
-  }
-  return { name, kind: '月令格', evidence: ex };
-}
-
-// ── 特殊格 / 组合 ────────────────────────────────────────────
-
-const ZHUANWANG = { 木: '曲直格', 火: '炎上格', 土: '稼穑格', 金: '从革格', 水: '润下格' };
-const CONG = { 财: '从财格', 官杀: '从杀格', 食伤: '从儿格', 印: '从强格', 比劫: '从强格' };
-const POS_LABEL = { year: '年', month: '月', day: '日', hour: '时' };
-
-// 日主根气：地支藏干里的同类（比劫）与生我（印），以及天干（日干除外）透出的比劫/印。
-// 只用于真从/假从：无根才是真从，有中气/余气微根或虚透只能算假从；
-// 见一个本气根（≥1 分）就不作从格——日主已能站住，再称从会误判。
-function rootProfile(pillars, dayStem) {
-  const me = STEM_ELEMENT[dayStem];
-  const out = { bi: 0, yin: 0, total: 0, details: [], helpers: [] };
-  for (const key of ['year', 'month', 'day', 'hour']) {
-    const branch = pillars[key].branch;
-    (HIDDEN[branch] || []).forEach((stem, i) => {
-      const el = STEM_ELEMENT[stem];
-      const w = HIDDEN_W[i] ?? 0.1;
-      if (el === me) {
-        out.bi += w;
-        out.details.push(`${POS_LABEL[key]}支${branch}藏${stem}（比劫 ${w}）`);
-      } else if (GENERATES[el] === me) {
-        out.yin += w;
-        out.details.push(`${POS_LABEL[key]}支${branch}藏${stem}（印 ${w}）`);
-      }
-    });
-  }
-  for (const key of ['year', 'month', 'hour']) {
-    const stem = pillars[key].stem;
-    const el = STEM_ELEMENT[stem];
-    if (el === me || GENERATES[el] === me) out.helpers.push(`${POS_LABEL[key]}干${stem}（${el === me ? '比劫' : '印'}）`);
-  }
-  out.bi = Math.round(out.bi * 10) / 10;
-  out.yin = Math.round(out.yin * 10) / 10;
-  out.total = Math.round((out.bi + out.yin) * 10) / 10;
-  return out;
-}
-
-function specialPatterns(pillars, dayStem, monthBranch, strength, wuxing, gods) {
-  const out = [];
-  const roles = elementRoles(dayStem);
-  const me = roles.me;
-  const mine = wuxing[me] ?? 0;
-  const yin = wuxing[roles.inMe] ?? 0;
-  const cai = wuxing[roles.cai] ?? 0;
-  const guan = wuxing[roles.guan] ?? 0;
-  const shi = wuxing[roles.shi] ?? 0;
-
-  // 化气格：日干与年/月/时干五合，且月令助化神
-  for (const key of ['year', 'month', 'hour']) {
-    const other = pillars[key].stem;
-    const target = STEM_HE[dayStem + other] || STEM_HE[other + dayStem];
-    if (!target) continue;
-    const monthEl = BRANCH_ELEMENT[monthBranch];
-    const supports = monthEl === target || GENERATES[monthEl] === target;
-    if (!supports) continue;
-    out.push({
-      name: `${target === '土' ? '化土格' : `化${target}格`}`,
-      kind: '化气格',
-      evidence: `日干${dayStem}与${['年', '月', '时'][['year', 'month', 'hour'].indexOf(key)]}干${other}合化${target}，月令${monthBranch}${monthEl}${monthEl === target ? '同化神' : '生助化神'}；化气格须全局无争合妒合才算真，此处仅列条件` ,
-    });
-    break;
-  }
-
-  // 专旺：日主之气独旺，官杀、财星皆弱。
-  // 成格＝旺神得月令（同类或印）且不见破；待定＝气势已成但月令不助；破格＝官杀逆势或财星耗旺。
-  if ((strength.level === '身强' || strength.level === '偏强') && mine + yin >= 5) {
-    const breaks = [];
-    if (guan > 1.2) breaks.push(`官杀 ${guan} 分，逆旺势`);
-    if (cai > 1.8) breaks.push(`财 ${cai} 分，耗旺气`);
-    const monthEl = BRANCH_ELEMENT[monthBranch];
-    const monthSupport = monthEl === me || monthEl === roles.inMe;
-    const group = SANHE_GROUPS.find((g) => g.element === me);
-    const branches = ['year', 'month', 'day', 'hour'].map((k) => pillars[k].branch);
-    const ju = group && group.branches.every((b) => branches.includes(b)) ? group.branches.join('') : null;
-    const status = breaks.length ? '破格' : monthSupport ? '成格' : '待定';
-    out.push({
-      name: ZHUANWANG[me],
-      kind: '专旺格',
-      status,
-      breaks,
-      ju,
-      evidence: `日主${me}得${mine + yin}分（同类+印），官杀${guan}、财${cai}${breaks.length ? '' : '皆弱'}；`
-        + `${monthSupport ? `月令${monthBranch}${monthEl}助旺` : `月令${monthBranch}${monthEl}不助旺`}`
-        + `${ju ? `，地支${ju}成局` : ''}，${status === '成格' ? '成格' : status === '破格' ? '见破格条件' : '成势而条件未全'}`,
-      breakRule: breaks.length ? '专旺以官杀逆旺势、财星耗旺气为破；见其一即不纯' : undefined,
-    });
-  }
-
-  // 从格：日主无根而被他神主导。真从＝完全无根、无比劫印绶透出；
-  // 假从＝有微根或虚透，气势仍从，但行运助身则不再从。
-  const root = rootProfile(pillars, dayStem);
-  if (root.total < 1 && (strength.level === '身弱' || strength.level === '偏弱')) {
-    const main = Object.entries({ 财: cai, 官杀: guan, 食伤: shi, 印: yin })
-      .sort((a, b) => b[1] - a[1])[0];
-    if (main[1] >= 2.5) {
-      const fake = root.total > 0 || root.helpers.length > 0;
-      const reasons = [...root.details, ...root.helpers.map((h) => `天干${h}虚透`)];
-      out.push({
-        name: CONG[main[0]],
-        kind: '从格',
-        status: fake ? '假从' : '真从',
-        breaks: fake ? reasons : [],
-        rootWeight: root.total,
-        evidence: fake
-          ? `日主有微根或虚透（${reasons.join('；')}），${main[0]}占 ${main[1]} 分最旺，假从${main[0]}；行运助身则不从`
-          : `日主无根（四支藏干无同类与印、天干无比劫印绶），${main[0]}占 ${main[1]} 分最旺，真从${main[0]}`,
-        breakRule: fake ? '从格以日主有根、比劫印绶透出为破；有根而从者称假从，运助身则不从' : undefined,
-      });
-    }
-  }
-
-  // 常见组合（只报事实并列，不作吉凶断语）
-  const byGod = gods.byGod || {};
-  const g = gods.groups || gods;
-  const hasGod = (name) => (byGod[name] ?? 0) >= 0.5;
-  const yinGods = (byGod.正印 ?? 0) + (byGod.偏印 ?? 0);
-  const combos = [
-    ['官印相生', hasGod('正官') && yinGods >= 0.5, `正官与印并见，官生印而护身`],
-    ['杀印相生', hasGod('七杀') && yinGods >= 0.5 && (byGod.七杀 ?? 0) > (byGod.正官 ?? 0), `七杀与印并见，杀印相生`],
-    ['食伤生财', (g.食伤 ?? 0) >= 0.6 && (g.财 ?? 0) >= 0.6, `食伤${g.食伤}+财${g.财}，食伤生财`],
-    ['财官相生', (g.财 ?? 0) >= 0.6 && (g.官杀 ?? 0) >= 0.6, `财${g.财}+官杀${g.官杀}，财生官`],
-    ['伤官配印', hasGod('伤官') && yinGods >= 0.5 && (g.财 ?? 0) <= 1, `伤官与印并见，伤官配印`],
-    ['伤官见官', hasGod('伤官') && hasGod('正官'), `伤官与正官并见（伤官见官，为祸百端之说）`],
-    ['羊刃驾杀', (g.官杀 ?? 0) >= 1 && YANGREN_BRANCH[dayStem] === monthBranch, `月令为刃，又有七杀${g.官杀}，刃杀相制`],
-  ];
-  for (const [name, cond, evidence] of combos) if (cond) out.push({ name, kind: '组合', evidence });
-  return out;
-}
-
-// ── 通关 ────────────────────────────────────────────────────
-// 滴天髓「通关」只给取象（织女、牛郎），这里把结构说清：
-// 用神与忌神两行在局中都真有分量、且相克时，五行里恰有一行能接上——克方所生、且能生被克方。
-// 只报这一行在局中的分量，不判「关通了就吉」。
-const TONGGUAN_MIN = 1.5;
-/** 忌神在全局不足这个分量时，展示层降为「中性偏忌」（仍留在 avoid 里参与行运评分） */
-const NEUTRAL_MAX = 0.5;
-function tongguanOf(favor = [], avoid = [], wuxing = {}) {
-  const w = (el) => Math.round((Number(wuxing[el]) || 0) * 10) / 10;
-  for (const use of favor) {
-    if (w(use) < TONGGUAN_MIN) continue;
-    for (const foe of avoid) {
-      if (OVERCOMES[foe] !== use || w(foe) < TONGGUAN_MIN) continue;
-      const bridge = GENERATES[foe];
-      if (!bridge || GENERATES[bridge] !== use) continue;
-      const weight = w(bridge);
-      const bridgeIsAvoid = avoid.includes(bridge) && !favor.includes(bridge);
-      const level = bridgeIsAvoid ? '为忌' : weight >= TONGGUAN_MIN ? '可通' : weight > 0 ? '关弱' : '未通';
-      return {
-        use, foe, bridge,
-        weight,
-        present: weight > 0,
-        bridgeIsAvoid,
-        level,
-        usable: level === '可通',
-        note: '相战＝用神与忌神两行各在局中 ≥1.5 分且相克；通关一行＝克方所生、又能生用神的那一行（五行里唯一），只报局中分量，不据此断吉凶',
-      };
-    }
-  }
-  return null;
-}
-
-// ── 用神 / 喜忌 ──────────────────────────────────────────────
-
-
-function yongshenOf(dayStem, monthBranch, strength, wuxing, branches = []) {
-  const roles = elementRoles(dayStem);
-  const me = roles.me;
-  const weak = strength.level === '身弱' || strength.level === '偏弱';
-  const strong = strength.level === '身强' || strength.level === '偏强';
-  const roleName = (el) => (el === me ? '比劫' : el === roles.inMe ? '印'
-    : el === roles.shi ? '食伤' : el === roles.cai ? '财' : '官杀');
-  const ROLE_VERB = { 比劫: '帮身', 印: '生身', 食伤: '泄秀', 财: '耗', 官杀: '制' };
-
-  const baseFavor = weak ? [roles.inMe, me] : strong ? [roles.shi, roles.cai, roles.guan] : [roles.inMe, me, roles.shi];
-  const baseAvoid = weak ? [roles.shi, roles.cai, roles.guan] : strong ? [me, roles.inMe] : [roles.guan, roles.cai];
-  let favor = baseFavor.slice();
-  let avoid = baseAvoid.slice();
-  // 调候所忌若正好是扶抑所喜（弱土遇燥的火、寒湿盘的强土遇水），两边不能同时列。
-  // 本表保留在喜用、不列入忌，并单列「有争议」；否则摘要会出现同一行既喜又忌。
-  const disputed = [];
-
-  // 先判气候，再决定要不要让调候压过扶抑
-  const climate = judgeClimate({ monthBranch, dayStem, wuxing, branches });
-  // 《穷通宝鉴》120 格：同一「日主 + 月令」的取用顺序。只作展示与加权，不覆盖气候调候
-  const qt = qtOf(dayStem, monthBranch);
-  const arb = arbitrate(climate, baseFavor, baseAvoid);
-  if (climate.need && climate.priority === '调候优先') {
-    const needEl = climate.need.element;
-    if (!favor.includes(needEl)) favor.unshift(needEl);
-    avoid = avoid.filter((e) => e !== needEl);
-    const badEl = climate.avoidElement;
-    if (badEl && favor.includes(badEl)) {
-      disputed.push({
-        element: badEl,
-        favorRole: roleName(badEl),
-        favorVerb: ROLE_VERB[roleName(badEl)],
-        climate: climate.label,
-        note: `调候忌${badEl}（${climate.label}），但它在扶抑里为${roleName(badEl)}；本表保留在喜用，不列入忌。`,
-      });
-    } else if (badEl && !avoid.includes(badEl)) {
-      avoid.unshift(badEl);
-    }
-  }
-
-  const expand = {
-    比劫: ['比肩', '劫财'], 印: ['正印', '偏印'], 食伤: ['食神', '伤官'],
-    财: ['正财', '偏财'], 官杀: ['正官', '七杀'],
-  };
-  const favorTenGods = Array.from(new Set(favor.flatMap((el) => expand[roleName(el)] || [])));
-  const avoidTenGods = Array.from(new Set(avoid.flatMap((el) => expand[roleName(el)] || [])));
-  const disputedTenGods = Array.from(new Set(disputed.flatMap((d) => expand[roleName(d.element)] || [])));
-  // 中性偏忌：忌神里全局分量极轻（不足 NEUTRAL_MAX 分）的那些。
-  // 不从 avoid 里删——行运评分要让「这一行走运到位」仍按忌计分：局中没有，不等于运里不来。
-  // 只在展示层把它们从「实忌」降为「中性偏忌」，避免把一张几乎无该行的盘说成三行皆忌。
-  const weightOf = (el) => Math.round((Number(wuxing[el]) || 0) * 10) / 10;
-  const neutral = avoid
-    .filter((el) => weightOf(el) < NEUTRAL_MAX)
-    .map((el) => ({ element: el, role: roleName(el), verb: ROLE_VERB[roleName(el)], weight: weightOf(el) }));
-  const neutralTenGods = Array.from(new Set(neutral.flatMap((n) => expand[n.role] || [])));
-  const tongguan = tongguanOf(favor, avoid, wuxing);
-
-  const describe = (el) => `${el}（${roleName(el)}·${ROLE_VERB[roleName(el)]}）`;
-  const disputedText = disputed
-    .map((d) => `${d.element}（扶抑为${d.favorRole}·${d.favorVerb}；${d.climate}盘调候忌${d.element}，本表保留在喜用）`)
-    .join('、');
-  const detail = [
-    `日主${dayStem}${me}，${strength.level}（${strength.score} 分）：`,
-    `喜${favor.map(describe).join('、') || '—'}；忌${avoid.map(describe).join('、') || '—'}。`,
-    neutral.length
-      ? `中性偏忌：${neutral.map((n) => `${n.element}（局中 ${n.weight} 分）`).join('、')}——分量近零，不作实忌论，但不从此盘喜忌中删除（行运遇之仍按忌计）。`
-      : '',
-    disputed.length ? `有争议：${disputedText}。` : '',
-    !weak && !strong ? '身中和，先取调候与通关，喜忌随大运流年动态变化。' : '',
-    `调候：${climate.label}（${(climate.evidence || []).join('、')}）${climate.need ? `，取${climate.need.stem}${climate.need.element}，忌${climate.avoidElement}${disputed.some((d) => d.element === climate.avoidElement) ? '（有争议）' : ''}` : '，气候平和'}。`,
-    qt ? `穷通宝鉴：${qt.month}${dayStem}${me}，用神${qt.yong.join('、')}（首取${qt.primary}）。` : '',
-    tongguan
-      ? `通关：忌${tongguan.foe}克用${tongguan.use}，五行以${tongguan.bridge}为关；局中${tongguan.level === '可通'
-        ? `${tongguan.bridge} ${tongguan.weight} 分，关可通`
-        : tongguan.level === '关弱'
-          ? `仅 ${tongguan.bridge} ${tongguan.weight} 分，关弱`
-          : tongguan.level === '为忌'
-            ? `${tongguan.bridge} ${tongguan.weight} 分但此行为忌，通关力打折`
-            : `未见${tongguan.bridge}，关未通`}（只作结构提示，不据此断吉凶）。`
-      : '',
-    arb.text,
-    arb.clash ? '取舍：本盘按「调候优先、扶抑次之」取用；若你更认同扶抑派，可把调候当环境偏好，强弱判断不受影响。' : '',
-  ].filter(Boolean).join('');
-
-  return {
-    method: climate.priority === '调候优先' ? '调候优先 + 扶抑校验' : '扶抑为主 + 调候校验',
-    level: strength.level,
-    favor,
-    avoid,
-    disputed,
-    neutral,
-    favorRoles: favor.map(roleName),
-    avoidRoles: avoid.map(roleName),
-    neutralRoles: neutral.map((n) => n.role),
-    favorTenGods,
-    avoidTenGods,
-    disputedTenGods,
-    neutralTenGods,
-    tiaohou: { ...climate, ...arb, element: climate.need ? climate.need.element : null },
-    climate,
-    qt,
-    tongguan,
-    detail,
-  };
-}
-
-// ── 行运评分 ────────────────────────────────────────────────
-
-const TIERS = [
-  [1.3, '大吉'],
-  [0.6, '吉'],
-  [-0.6, '平'],
-  [-1.3, '忌'],
-  [-Infinity, '大忌'],
-];
-
-function scoreLuck(ganzhi, frame) {
-  const ys = frame.yongshen;
-  const stem = ganzhi[0];
-  const branch = ganzhi[1];
-  const stemEl = STEM_ELEMENT[stem];
-  const branchEl = BRANCH_ELEMENT[branch];
-  const th = ys.tiaohou || ys.climate || null;
-  const scoreEl = (el) => {
-    let s = 0;
-    if (ys.favor.includes(el)) s += 1;
-    if (ys.avoid.includes(el)) s -= 1;
-    return s;
-  };
-  let score = scoreEl(stemEl) * 1.0 + scoreEl(branchEl) * 0.8;
-  for (const h of (HIDDEN[branch] || []).slice(1)) {
-    score += scoreEl(STEM_ELEMENT[h]) * 0.2;
-  }
-
-  const reasons = [];
-  if (ys.favor.includes(stemEl)) reasons.push(`天干${stem}${stemEl}为用神`);
-  else if (ys.avoid.includes(stemEl)) reasons.push(`天干${stem}${stemEl}为忌神`);
-  else reasons.push(`天干${stem}${stemEl}不喜不忌`);
-  if (ys.favor.includes(branchEl)) reasons.push(`地支${branch}${branchEl}助用`);
-  else if (ys.avoid.includes(branchEl)) reasons.push(`地支${branch}${branchEl}助忌`);
-
-  // 调候修正：不是"有没有这个五行"，而是"这一年是给命局添了一把火，还是泼了一盆水"
-  if (th && th.need && th.priority === '调候优先') {
-    const needEl = th.need.element;
-    const oppEl = th.avoidElement;
-    const cold = String(th.kind).includes('寒');
-    if (stemEl === needEl) {
-      score += 1.1;
-      reasons.push(`${th.label}之局得${stem}${stemEl}，${cold ? '解冻' : '得润'}`);
-    } else if (stemEl === oppEl) {
-      score -= 0.9;
-      reasons.push(`${th.label}之局再逢${stem}${stemEl}，${cold ? '冻木难生' : '燥上加燥'}`);
-    }
-    if (branchEl === needEl) {
-      score += 0.9;
-      reasons.push(`地支${branch}${branchEl}合调候`);
-    } else if (branchEl === oppEl) {
-      score -= 1.0;
-      reasons.push(`地支${branch}${branchEl}加重${th.label}`);
-    }
-    if (cold && (stemEl === '水' || branchEl === '水')) score -= 0.3;
-  } else if (th && th.need && (stemEl === th.need.element || branchEl === th.need.element)) {
-    reasons.push(`合调候（${th.need.element}）`);
-  }
-
-  const godStem = tenGod(frame.dayStem, stem);
-  const bonus = ys.favorTenGods.includes(godStem) ? 0.3 : 0;
-  // 穷通宝鉴：天干正好是这一格的首取/次取时，再给一点「按书取用」的分
-  // 只在该干不属于忌神时加分——书里的取用与气候调候不同向时，以调候为先
-  const qt = ys.qt || null;
-  if (qt && qt.primary && !ys.avoid.includes(STEM_ELEMENT[qt.primary])) {
-    if (stem === qt.primary) {
-      score += 0.3;
-      reasons.push(`天干${stem}正是${qt.branch}月${qt.stem}日的首取（穷通宝鉴）`);
-    } else if (qt.yong.includes(stem) && !ys.avoid.includes(STEM_ELEMENT[stem])) {
-      score += 0.15;
-      reasons.push(`天干${stem}为穷通宝鉴次取`);
-    }
-  }
-  let total = Math.round((score + bonus) * 10) / 10;
-  total = Math.max(-4, Math.min(4, total));
-
-  const tier = TIERS.find(([min]) => total >= min)[1];
-  return { ganzhi, score: total, tier, stemTenGod: godStem, reasons, note: `${godStem}运，${tier}（${total}）` };
-}
-
-// ── 对外入口 ────────────────────────────────────────────────
-
-/**
- * @param {object} p
- * @param {object} p.pillars 四柱
- * @param {string} p.dayStem 日干
- * @param {string} p.monthBranch 月支
- * @param {object} p.strength bazi.js 的旺衰结果
- * @param {object} p.wuxing 五行分值
- */
-function analyzeBaziFrame({ pillars, dayStem, monthBranch, strength, wuxing }) {
-  const gods = godStats(pillars, dayStem);
-  const month = monthPattern(pillars, dayStem, monthBranch);
-  const special = specialPatterns(pillars, dayStem, monthBranch, strength, wuxing, gods);
-  const geju = [month, ...special];
-  const yongshen = yongshenOf(dayStem, monthBranch, strength, wuxing, Object.values(pillars).map((p) => p.branch));
-  return {
-    geju,
-    primary: month,
-    primaryName: month.name,
-    godStats: gods,
-    yongshen,
-    dayStem,
-    monthBranch,
-  };
-}
+// 八字格局、用神与行运评分
+//
+// 定位：在 bazi.js 算出四柱、五行、旺衰之后，给出
+//   1) 格局（月令格 + 特殊格 + 常见组合）；
+//   2) 用神 / 喜忌（调候优先 + 扶抑校验；气候平和时仍以扶抑为主）；
+//   3) 大运、流年的吉凶倾向评分（含调候修正项）。
+// 取舍：格局派别差异极大，这里只给「规则可复核」的判定，evidence 写明依据；
+// 调候由 tiaohou.js 独立判定，与扶抑冲突时显式裁决并写明理由，不静默取用。
+
+const { judgeClimate, arbitrate } = (__mods.tiaohou || {});
+const { qtOf } = (__mods.qiongtong || {});
+const { SANHE_GROUPS, sanheGroupOf } = (__mods.sanhe || {});
+
+const STEMS = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
+const BRANCHES = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];
+
+const STEM_ELEMENT = {
+  甲: '木', 乙: '木', 丙: '火', 丁: '火', 戊: '土',
+  己: '土', 庚: '金', 辛: '金', 壬: '水', 癸: '水',
+};
+const BRANCH_ELEMENT = {
+  子: '水', 丑: '土', 寅: '木', 卯: '木', 辰: '土', 巳: '火',
+  午: '火', 未: '土', 申: '金', 酉: '金', 戌: '土', 亥: '水',
+};
+const GENERATES = { 木: '火', 火: '土', 土: '金', 金: '水', 水: '木' };
+const OVERCOMES = { 木: '土', 土: '水', 水: '火', 火: '金', 金: '木' };
+const HIDDEN = {
+  子: ['癸'], 丑: ['己', '癸', '辛'], 寅: ['甲', '丙', '戊'], 卯: ['乙'],
+  辰: ['戊', '乙', '癸'], 巳: ['丙', '戊', '庚'], 午: ['丁', '己'], 未: ['己', '丁', '乙'],
+  申: ['庚', '壬', '戊'], 酉: ['辛'], 戌: ['戊', '辛', '丁'], 亥: ['壬', '甲'],
+};
+const HIDDEN_W = [1, 0.5, 0.3];
+
+const LUSHEN_BRANCH = { 甲: '寅', 乙: '卯', 丙: '巳', 丁: '午', 戊: '巳', 己: '午', 庚: '申', 辛: '酉', 壬: '亥', 癸: '子' };
+const YANGREN_BRANCH = { 甲: '卯', 乙: '辰', 丙: '午', 丁: '未', 戊: '午', 己: '未', 庚: '酉', 辛: '戌', 壬: '子', 癸: '丑' };
+const STEM_HE = { 甲己: '土', 乙庚: '金', 丙辛: '水', 丁壬: '木', 戊癸: '火' };
+
+const isYangStem = (s) => STEMS.indexOf(s) % 2 === 0;
+const ELEMENTS = ['木', '火', '土', '金', '水'];
+
+/** 十神：以日干为我（与 bazi.js 同规则） */
+function tenGod(dayStem, otherStem) {
+  const me = STEM_ELEMENT[dayStem];
+  const it = STEM_ELEMENT[otherStem];
+  const same = isYangStem(dayStem) === isYangStem(otherStem);
+  if (me === it) return same ? '比肩' : '劫财';
+  if (GENERATES[me] === it) return same ? '食神' : '伤官';
+  if (OVERCOMES[me] === it) return same ? '偏财' : '正财';
+  if (OVERCOMES[it] === me) return same ? '七杀' : '正官';
+  if (GENERATES[it] === me) return same ? '偏印' : '正印';
+  return '?';
+}
+
+const godGroups = {
+  比劫: ['比肩', '劫财'],
+  食伤: ['食神', '伤官'],
+  财: ['正财', '偏财'],
+  官杀: ['正官', '七杀'],
+  印: ['正印', '偏印'],
+};
+
+/** 全局十神权重：四柱天干 1.0，地支藏干按本气 1 / 中气 0.5 / 余气 0.3 */
+function godStats(pillars, dayStem) {
+  const total = { 比劫: 0, 食伤: 0, 财: 0, 官杀: 0, 印: 0 };
+  const byGod = { 比肩: 0, 劫财: 0, 食神: 0, 伤官: 0, 正财: 0, 偏财: 0, 正官: 0, 七杀: 0, 正印: 0, 偏印: 0 };
+  const add = (stem, w) => {
+    const god = tenGod(dayStem, stem);
+    const g = Object.keys(godGroups).find((k) => godGroups[k].includes(god));
+    if (g) total[g] += w;
+    if (byGod[god] !== undefined) byGod[god] += w;
+  };
+  // 时辰未知时 pillars.hour 为 null：遍历跳过，不能对 null 取 .stem
+  for (const key of ['year', 'month', 'day', 'hour'].filter((k) => pillars[k])) {
+    add(pillars[key].stem, key === 'day' ? 0.6 : 1);
+    (HIDDEN[pillars[key].branch] || []).forEach((h, i) => add(h, HIDDEN_W[i] ?? 0.1));
+  }
+  for (const k of Object.keys(total)) total[k] = Math.round(total[k] * 10) / 10;
+  for (const k of Object.keys(byGod)) byGod[k] = Math.round(byGod[k] * 10) / 10;
+  return { groups: total, byGod };
+}
+
+/** 用神所属五行：生我 / 同我 / 我生 / 我克 / 克我 */
+function elementRoles(dayStem) {
+  const me = STEM_ELEMENT[dayStem];
+  const inMe = ELEMENTS.find((e) => GENERATES[e] === me);
+  const guan = ELEMENTS.find((e) => OVERCOMES[e] === me);
+  return { me, inMe, shi: GENERATES[me], cai: OVERCOMES[me], guan };
+}
+
+// ── 月令格 ───────────────────────────────────────────────────
+
+// 四墓（杂气）月：辰戌丑未所藏多、用神不一，取用先看透干，再看会支。
+// 会支只认三合局——子平真诠十六「逢申与子会局」的例子即三合，三会方与兼透兼用仍不纳入。
+const ZA_MONTHS = ['辰', '未', '戌', '丑'];
+
+function huiCandidate(pillars, monthBranch, cands) {
+  if (!ZA_MONTHS.includes(monthBranch)) return null;
+  const group = sanheGroupOf(monthBranch);
+  if (!group) return null;
+  const others = ['year', 'day', 'hour'];
+  const need = group.branches.filter((b) => b !== monthBranch);
+  if (!need.every((b) => others.some((k) => pillars[k].branch === b))) return null;
+  const cand = cands.find((c) => STEM_ELEMENT[c.stem] === group.element);
+  if (!cand) return null;
+  const where = others
+    .filter((k) => need.includes(pillars[k].branch))
+    .map((k) => `${({ year: '年', day: '日', hour: '时' })[k]}支${pillars[k].branch}`);
+  return { ...cand, group, where };
+}
+
+function monthPattern(pillars, dayStem, monthBranch) {
+  const hidden = HIDDEN[monthBranch] || [];
+  const cands = hidden.map((stem, i) => ({
+    stem,
+    god: tenGod(dayStem, stem),
+    pos: ['本气', '中气', '余气'][i],
+    w: HIDDEN_W[i] ?? 0.1,
+  }));
+  const others = ['year', 'month', 'hour'];
+  const exposedKey = others.find((k) => cands.some((c) => c.stem === pillars[k].stem));
+  const base = cands[0];
+  const hui = exposedKey ? null : huiCandidate(pillars, monthBranch, cands);
+  const use = exposedKey ? cands.find((c) => c.stem === pillars[exposedKey].stem) : (hui || base);
+  const usedBy = exposedKey ? '透干' : (hui ? '会支' : '本气');
+  const exposedPos = exposedKey ? { year: '年', month: '月', hour: '时' }[exposedKey] : null;
+
+  // 建禄只认日干的禄位；戊土辰月、己土未月这类「本气比肩但不在禄位」的杂气月不再冒称建禄
+  if (base.god === '比肩' && LUSHEN_BRANCH[dayStem] === monthBranch) {
+    return {
+      name: '建禄格',
+      kind: '月令格',
+      evidence: `月令${monthBranch}为日干${dayStem}之禄（本气${base.stem}比肩），身坐禄地`,
+    };
+  }
+  if (base.god === '劫财') {
+    if (YANGREN_BRANCH[dayStem] === monthBranch) {
+      return {
+        name: isYangStem(dayStem) ? '阳刃格' : '月刃格',
+        kind: '月令格',
+        evidence: `月令${monthBranch}为日干${dayStem}之刃（本气${base.stem}劫财）${isYangStem(dayStem) ? '' : '，阴干统称月刃'}`,
+      };
+    }
+    return { name: '月劫格', kind: '月令格', evidence: `月令${monthBranch}本气${base.stem}为劫财` };
+  }
+  if (usedBy === '本气' && base.god === '比肩') {
+    return {
+      name: '比肩格',
+      kind: '月令格',
+      evidence: `月令${monthBranch}藏${hidden.join('')}，本气${base.stem}为比肩，但${dayStem}禄在${LUSHEN_BRANCH[dayStem]}、不在${monthBranch}，属杂气月比肩当权`,
+    };
+  }
+  // 子平十六：「透乙则用月劫」——杂气月由透干或会支取到劫财时，仍作月劫论
+  if (usedBy !== '本气' && use.god === '劫财') {
+    const via = exposedKey ? `透于${exposedPos}干` : `${hui.where.join('、')}会成${hui.group.element}局`;
+    return {
+      name: '月劫格',
+      kind: '月令格',
+      evidence: `月令${monthBranch}藏${hidden.join('')}，${use.pos}${use.stem}（劫财）${via}，劫财为用，作月劫论`,
+    };
+  }
+  const name = `${use.god}格`;
+  let ex;
+  if (exposedKey) {
+    ex = `月令${monthBranch}藏${hidden.join('')}，${use.pos}${use.stem}（${use.god}）透于${exposedPos}干`;
+  } else if (hui) {
+    ex = `月令${monthBranch}藏${hidden.join('')}，本气${base.stem}（${base.god}）未透干，而${hui.where.join('、')}会成${hui.group.element}局，取${use.pos}${use.stem}（${use.god}）为用`;
+  } else {
+    ex = `月令${monthBranch}藏${hidden.join('')}，本气${base.stem}（${base.god}）未透干，以月令本气取格`;
+  }
+  return { name, kind: '月令格', evidence: ex };
+}
+
+// ── 特殊格 / 组合 ────────────────────────────────────────────
+
+const ZHUANWANG = { 木: '曲直格', 火: '炎上格', 土: '稼穑格', 金: '从革格', 水: '润下格' };
+const CONG = { 财: '从财格', 官杀: '从杀格', 食伤: '从儿格', 印: '从强格', 比劫: '从强格' };
+const POS_LABEL = { year: '年', month: '月', day: '日', hour: '时' };
+
+// 日主根气：地支藏干里的同类（比劫）与生我（印），以及天干（日干除外）透出的比劫/印。
+// 只用于真从/假从：无根才是真从，有中气/余气微根或虚透只能算假从；
+// 见一个本气根（≥1 分）就不作从格——日主已能站住，再称从会误判。
+function rootProfile(pillars, dayStem) {
+  const me = STEM_ELEMENT[dayStem];
+  const out = { bi: 0, yin: 0, total: 0, details: [], helpers: [] };
+  for (const key of ['year', 'month', 'day', 'hour'].filter((k) => pillars[k])) {
+    const branch = pillars[key].branch;
+    (HIDDEN[branch] || []).forEach((stem, i) => {
+      const el = STEM_ELEMENT[stem];
+      const w = HIDDEN_W[i] ?? 0.1;
+      if (el === me) {
+        out.bi += w;
+        out.details.push(`${POS_LABEL[key]}支${branch}藏${stem}（比劫 ${w}）`);
+      } else if (GENERATES[el] === me) {
+        out.yin += w;
+        out.details.push(`${POS_LABEL[key]}支${branch}藏${stem}（印 ${w}）`);
+      }
+    });
+  }
+  for (const key of ['year', 'month', 'hour']) {
+    const stem = pillars[key].stem;
+    const el = STEM_ELEMENT[stem];
+    if (el === me || GENERATES[el] === me) out.helpers.push(`${POS_LABEL[key]}干${stem}（${el === me ? '比劫' : '印'}）`);
+  }
+  out.bi = Math.round(out.bi * 10) / 10;
+  out.yin = Math.round(out.yin * 10) / 10;
+  out.total = Math.round((out.bi + out.yin) * 10) / 10;
+  return out;
+}
+
+function specialPatterns(pillars, dayStem, monthBranch, strength, wuxing, gods) {
+  const out = [];
+  const roles = elementRoles(dayStem);
+  const me = roles.me;
+  const mine = wuxing[me] ?? 0;
+  const yin = wuxing[roles.inMe] ?? 0;
+  const cai = wuxing[roles.cai] ?? 0;
+  const guan = wuxing[roles.guan] ?? 0;
+  const shi = wuxing[roles.shi] ?? 0;
+
+  // 化气格：日干与年/月/时干五合，且月令助化神
+  for (const key of ['year', 'month', 'hour']) {
+    const other = pillars[key].stem;
+    const target = STEM_HE[dayStem + other] || STEM_HE[other + dayStem];
+    if (!target) continue;
+    const monthEl = BRANCH_ELEMENT[monthBranch];
+    const supports = monthEl === target || GENERATES[monthEl] === target;
+    if (!supports) continue;
+    out.push({
+      name: `${target === '土' ? '化土格' : `化${target}格`}`,
+      kind: '化气格',
+      evidence: `日干${dayStem}与${['年', '月', '时'][['year', 'month', 'hour'].indexOf(key)]}干${other}合化${target}，月令${monthBranch}${monthEl}${monthEl === target ? '同化神' : '生助化神'}；化气格须全局无争合妒合才算真，此处仅列条件` ,
+    });
+    break;
+  }
+
+  // 专旺：日主之气独旺，官杀、财星皆弱。
+  // 成格＝旺神得月令（同类或印）且不见破；待定＝气势已成但月令不助；破格＝官杀逆势或财星耗旺。
+  if ((strength.level === '身强' || strength.level === '偏强') && mine + yin >= 5) {
+    const breaks = [];
+    if (guan > 1.2) breaks.push(`官杀 ${guan} 分，逆旺势`);
+    if (cai > 1.8) breaks.push(`财 ${cai} 分，耗旺气`);
+    const monthEl = BRANCH_ELEMENT[monthBranch];
+    const monthSupport = monthEl === me || monthEl === roles.inMe;
+    const group = SANHE_GROUPS.find((g) => g.element === me);
+    const branches = ['year', 'month', 'day', 'hour'].filter((k) => pillars[k]).map((k) => pillars[k].branch);
+    const ju = group && group.branches.every((b) => branches.includes(b)) ? group.branches.join('') : null;
+    const status = breaks.length ? '破格' : monthSupport ? '成格' : '待定';
+    out.push({
+      name: ZHUANWANG[me],
+      kind: '专旺格',
+      status,
+      breaks,
+      ju,
+      evidence: `日主${me}得${mine + yin}分（同类+印），官杀${guan}、财${cai}${breaks.length ? '' : '皆弱'}；`
+        + `${monthSupport ? `月令${monthBranch}${monthEl}助旺` : `月令${monthBranch}${monthEl}不助旺`}`
+        + `${ju ? `，地支${ju}成局` : ''}，${status === '成格' ? '成格' : status === '破格' ? '见破格条件' : '成势而条件未全'}`,
+      breakRule: breaks.length ? '专旺以官杀逆旺势、财星耗旺气为破；见其一即不纯' : undefined,
+    });
+  }
+
+  // 从格：日主无根而被他神主导。真从＝完全无根、无比劫印绶透出；
+  // 假从＝有微根或虚透，气势仍从，但行运助身则不再从。
+  const root = rootProfile(pillars, dayStem);
+  if (root.total < 1 && (strength.level === '身弱' || strength.level === '偏弱')) {
+    const main = Object.entries({ 财: cai, 官杀: guan, 食伤: shi, 印: yin })
+      .sort((a, b) => b[1] - a[1])[0];
+    if (main[1] >= 2.5) {
+      const fake = root.total > 0 || root.helpers.length > 0;
+      const reasons = [...root.details, ...root.helpers.map((h) => `天干${h}虚透`)];
+      out.push({
+        name: CONG[main[0]],
+        kind: '从格',
+        status: fake ? '假从' : '真从',
+        breaks: fake ? reasons : [],
+        rootWeight: root.total,
+        evidence: fake
+          ? `日主有微根或虚透（${reasons.join('；')}），${main[0]}占 ${main[1]} 分最旺，假从${main[0]}；行运助身则不从`
+          : `日主无根（四支藏干无同类与印、天干无比劫印绶），${main[0]}占 ${main[1]} 分最旺，真从${main[0]}`,
+        breakRule: fake ? '从格以日主有根、比劫印绶透出为破；有根而从者称假从，运助身则不从' : undefined,
+      });
+    }
+  }
+
+  // 常见组合（只报事实并列，不作吉凶断语）
+  const byGod = gods.byGod || {};
+  const g = gods.groups || gods;
+  const hasGod = (name) => (byGod[name] ?? 0) >= 0.5;
+  const yinGods = (byGod.正印 ?? 0) + (byGod.偏印 ?? 0);
+  const combos = [
+    ['官印相生', hasGod('正官') && yinGods >= 0.5, `正官与印并见，官生印而护身`],
+    ['杀印相生', hasGod('七杀') && yinGods >= 0.5 && (byGod.七杀 ?? 0) > (byGod.正官 ?? 0), `七杀与印并见，杀印相生`],
+    ['食伤生财', (g.食伤 ?? 0) >= 0.6 && (g.财 ?? 0) >= 0.6, `食伤${g.食伤}+财${g.财}，食伤生财`],
+    ['财官相生', (g.财 ?? 0) >= 0.6 && (g.官杀 ?? 0) >= 0.6, `财${g.财}+官杀${g.官杀}，财生官`],
+    ['伤官配印', hasGod('伤官') && yinGods >= 0.5 && (g.财 ?? 0) <= 1, `伤官与印并见，伤官配印`],
+    ['伤官见官', hasGod('伤官') && hasGod('正官'), `伤官与正官并见（伤官见官，为祸百端之说）`],
+    ['羊刃驾杀', (g.官杀 ?? 0) >= 1 && YANGREN_BRANCH[dayStem] === monthBranch, `月令为刃，又有七杀${g.官杀}，刃杀相制`],
+  ];
+  for (const [name, cond, evidence] of combos) if (cond) out.push({ name, kind: '组合', evidence });
+  return out;
+}
+
+// ── 通关 ────────────────────────────────────────────────────
+// 滴天髓「通关」只给取象（织女、牛郎），这里把结构说清：
+// 用神与忌神两行在局中都真有分量、且相克时，五行里恰有一行能接上——克方所生、且能生被克方。
+// 只报这一行在局中的分量，不判「关通了就吉」。
+const TONGGUAN_MIN = 1.5;
+/** 忌神在全局不足这个分量时，展示层降为「中性偏忌」（仍留在 avoid 里参与行运评分） */
+const NEUTRAL_MAX = 0.5;
+function tongguanOf(favor = [], avoid = [], wuxing = {}) {
+  const w = (el) => Math.round((Number(wuxing[el]) || 0) * 10) / 10;
+  for (const use of favor) {
+    if (w(use) < TONGGUAN_MIN) continue;
+    for (const foe of avoid) {
+      if (OVERCOMES[foe] !== use || w(foe) < TONGGUAN_MIN) continue;
+      const bridge = GENERATES[foe];
+      if (!bridge || GENERATES[bridge] !== use) continue;
+      const weight = w(bridge);
+      const bridgeIsAvoid = avoid.includes(bridge) && !favor.includes(bridge);
+      const level = bridgeIsAvoid ? '为忌' : weight >= TONGGUAN_MIN ? '可通' : weight > 0 ? '关弱' : '未通';
+      return {
+        use, foe, bridge,
+        weight,
+        present: weight > 0,
+        bridgeIsAvoid,
+        level,
+        usable: level === '可通',
+        note: '相战＝用神与忌神两行各在局中 ≥1.5 分且相克；通关一行＝克方所生、又能生用神的那一行（五行里唯一），只报局中分量，不据此断吉凶',
+      };
+    }
+  }
+  return null;
+}
+
+// ── 用神 / 喜忌 ──────────────────────────────────────────────
+
+
+function yongshenOf(dayStem, monthBranch, strength, wuxing, branches = []) {
+  const roles = elementRoles(dayStem);
+  const me = roles.me;
+  const weak = strength.level === '身弱' || strength.level === '偏弱';
+  const strong = strength.level === '身强' || strength.level === '偏强';
+  const roleName = (el) => (el === me ? '比劫' : el === roles.inMe ? '印'
+    : el === roles.shi ? '食伤' : el === roles.cai ? '财' : '官杀');
+  const ROLE_VERB = { 比劫: '帮身', 印: '生身', 食伤: '泄秀', 财: '耗', 官杀: '制' };
+
+  const baseFavor = weak ? [roles.inMe, me] : strong ? [roles.shi, roles.cai, roles.guan] : [roles.inMe, me, roles.shi];
+  const baseAvoid = weak ? [roles.shi, roles.cai, roles.guan] : strong ? [me, roles.inMe] : [roles.guan, roles.cai];
+  let favor = baseFavor.slice();
+  let avoid = baseAvoid.slice();
+  // 调候所忌若正好是扶抑所喜（弱土遇燥的火、寒湿盘的强土遇水），两边不能同时列。
+  // 本表保留在喜用、不列入忌，并单列「有争议」；否则摘要会出现同一行既喜又忌。
+  const disputed = [];
+
+  // 先判气候，再决定要不要让调候压过扶抑
+  const climate = judgeClimate({ monthBranch, dayStem, wuxing, branches });
+  // 《穷通宝鉴》120 格：同一「日主 + 月令」的取用顺序。只作展示与加权，不覆盖气候调候
+  const qt = qtOf(dayStem, monthBranch);
+  const arb = arbitrate(climate, baseFavor, baseAvoid);
+  if (climate.need && climate.priority === '调候优先') {
+    const needEl = climate.need.element;
+    if (!favor.includes(needEl)) favor.unshift(needEl);
+    avoid = avoid.filter((e) => e !== needEl);
+    const badEl = climate.avoidElement;
+    if (badEl && favor.includes(badEl)) {
+      disputed.push({
+        element: badEl,
+        favorRole: roleName(badEl),
+        favorVerb: ROLE_VERB[roleName(badEl)],
+        climate: climate.label,
+        note: `调候忌${badEl}（${climate.label}），但它在扶抑里为${roleName(badEl)}；本表保留在喜用，不列入忌。`,
+      });
+    } else if (badEl && !avoid.includes(badEl)) {
+      avoid.unshift(badEl);
+    }
+  }
+
+  const expand = {
+    比劫: ['比肩', '劫财'], 印: ['正印', '偏印'], 食伤: ['食神', '伤官'],
+    财: ['正财', '偏财'], 官杀: ['正官', '七杀'],
+  };
+  const favorTenGods = Array.from(new Set(favor.flatMap((el) => expand[roleName(el)] || [])));
+  const avoidTenGods = Array.from(new Set(avoid.flatMap((el) => expand[roleName(el)] || [])));
+  const disputedTenGods = Array.from(new Set(disputed.flatMap((d) => expand[roleName(d.element)] || [])));
+  // 中性偏忌：忌神里全局分量极轻（不足 NEUTRAL_MAX 分）的那些。
+  // 不从 avoid 里删——行运评分要让「这一行走运到位」仍按忌计分：局中没有，不等于运里不来。
+  // 只在展示层把它们从「实忌」降为「中性偏忌」，避免把一张几乎无该行的盘说成三行皆忌。
+  const weightOf = (el) => Math.round((Number(wuxing[el]) || 0) * 10) / 10;
+  const neutral = avoid
+    .filter((el) => weightOf(el) < NEUTRAL_MAX)
+    .map((el) => ({ element: el, role: roleName(el), verb: ROLE_VERB[roleName(el)], weight: weightOf(el) }));
+  const neutralTenGods = Array.from(new Set(neutral.flatMap((n) => expand[n.role] || [])));
+  const tongguan = tongguanOf(favor, avoid, wuxing);
+
+  const describe = (el) => `${el}（${roleName(el)}·${ROLE_VERB[roleName(el)]}）`;
+  const disputedText = disputed
+    .map((d) => `${d.element}（扶抑为${d.favorRole}·${d.favorVerb}；${d.climate}盘调候忌${d.element}，本表保留在喜用）`)
+    .join('、');
+  const detail = [
+    `日主${dayStem}${me}，${strength.level}（${strength.score} 分）：`,
+    `喜${favor.map(describe).join('、') || '—'}；忌${avoid.map(describe).join('、') || '—'}。`,
+    neutral.length
+      ? `中性偏忌：${neutral.map((n) => `${n.element}（局中 ${n.weight} 分）`).join('、')}——分量近零，不作实忌论，但不从此盘喜忌中删除（行运遇之仍按忌计）。`
+      : '',
+    disputed.length ? `有争议：${disputedText}。` : '',
+    !weak && !strong ? '身中和，先取调候与通关，喜忌随大运流年动态变化。' : '',
+    `调候：${climate.label}（${(climate.evidence || []).join('、')}）${climate.need ? `，取${climate.need.stem}${climate.need.element}，忌${climate.avoidElement}${disputed.some((d) => d.element === climate.avoidElement) ? '（有争议）' : ''}` : '，气候平和'}。`,
+    qt ? `穷通宝鉴：${qt.month}${dayStem}${me}，用神${qt.yong.join('、')}（首取${qt.primary}）。` : '',
+    tongguan
+      ? `通关：忌${tongguan.foe}克用${tongguan.use}，五行以${tongguan.bridge}为关；局中${tongguan.level === '可通'
+        ? `${tongguan.bridge} ${tongguan.weight} 分，关可通`
+        : tongguan.level === '关弱'
+          ? `仅 ${tongguan.bridge} ${tongguan.weight} 分，关弱`
+          : tongguan.level === '为忌'
+            ? `${tongguan.bridge} ${tongguan.weight} 分但此行为忌，通关力打折`
+            : `未见${tongguan.bridge}，关未通`}（只作结构提示，不据此断吉凶）。`
+      : '',
+    arb.text,
+    arb.clash ? '取舍：本盘按「调候优先、扶抑次之」取用；若你更认同扶抑派，可把调候当环境偏好，强弱判断不受影响。' : '',
+  ].filter(Boolean).join('');
+
+  return {
+    method: climate.priority === '调候优先' ? '调候优先 + 扶抑校验' : '扶抑为主 + 调候校验',
+    level: strength.level,
+    favor,
+    avoid,
+    disputed,
+    neutral,
+    favorRoles: favor.map(roleName),
+    avoidRoles: avoid.map(roleName),
+    neutralRoles: neutral.map((n) => n.role),
+    favorTenGods,
+    avoidTenGods,
+    disputedTenGods,
+    neutralTenGods,
+    tiaohou: { ...climate, ...arb, element: climate.need ? climate.need.element : null },
+    climate,
+    qt,
+    tongguan,
+    detail,
+  };
+}
+
+// ── 行运评分 ────────────────────────────────────────────────
+
+const TIERS = [
+  [1.3, '大吉'],
+  [0.6, '吉'],
+  [-0.6, '平'],
+  [-1.3, '忌'],
+  [-Infinity, '大忌'],
+];
+
+function scoreLuck(ganzhi, frame) {
+  const ys = frame.yongshen;
+  const stem = ganzhi[0];
+  const branch = ganzhi[1];
+  const stemEl = STEM_ELEMENT[stem];
+  const branchEl = BRANCH_ELEMENT[branch];
+  const th = ys.tiaohou || ys.climate || null;
+  const scoreEl = (el) => {
+    let s = 0;
+    if (ys.favor.includes(el)) s += 1;
+    if (ys.avoid.includes(el)) s -= 1;
+    return s;
+  };
+  let score = scoreEl(stemEl) * 1.0 + scoreEl(branchEl) * 0.8;
+  for (const h of (HIDDEN[branch] || []).slice(1)) {
+    score += scoreEl(STEM_ELEMENT[h]) * 0.2;
+  }
+
+  const reasons = [];
+  if (ys.favor.includes(stemEl)) reasons.push(`天干${stem}${stemEl}为用神`);
+  else if (ys.avoid.includes(stemEl)) reasons.push(`天干${stem}${stemEl}为忌神`);
+  else reasons.push(`天干${stem}${stemEl}不喜不忌`);
+  if (ys.favor.includes(branchEl)) reasons.push(`地支${branch}${branchEl}助用`);
+  else if (ys.avoid.includes(branchEl)) reasons.push(`地支${branch}${branchEl}助忌`);
+
+  // 调候修正：不是"有没有这个五行"，而是"这一年是给命局添了一把火，还是泼了一盆水"
+  if (th && th.need && th.priority === '调候优先') {
+    const needEl = th.need.element;
+    const oppEl = th.avoidElement;
+    const cold = String(th.kind).includes('寒');
+    if (stemEl === needEl) {
+      score += 1.1;
+      reasons.push(`${th.label}之局得${stem}${stemEl}，${cold ? '解冻' : '得润'}`);
+    } else if (stemEl === oppEl) {
+      score -= 0.9;
+      reasons.push(`${th.label}之局再逢${stem}${stemEl}，${cold ? '冻木难生' : '燥上加燥'}`);
+    }
+    if (branchEl === needEl) {
+      score += 0.9;
+      reasons.push(`地支${branch}${branchEl}合调候`);
+    } else if (branchEl === oppEl) {
+      score -= 1.0;
+      reasons.push(`地支${branch}${branchEl}加重${th.label}`);
+    }
+    if (cold && (stemEl === '水' || branchEl === '水')) score -= 0.3;
+  } else if (th && th.need && (stemEl === th.need.element || branchEl === th.need.element)) {
+    reasons.push(`合调候（${th.need.element}）`);
+  }
+
+  const godStem = tenGod(frame.dayStem, stem);
+  const bonus = ys.favorTenGods.includes(godStem) ? 0.3 : 0;
+  // 穷通宝鉴：天干正好是这一格的首取/次取时，再给一点「按书取用」的分
+  // 只在该干不属于忌神时加分——书里的取用与气候调候不同向时，以调候为先
+  const qt = ys.qt || null;
+  if (qt && qt.primary && !ys.avoid.includes(STEM_ELEMENT[qt.primary])) {
+    if (stem === qt.primary) {
+      score += 0.3;
+      reasons.push(`天干${stem}正是${qt.branch}月${qt.stem}日的首取（穷通宝鉴）`);
+    } else if (qt.yong.includes(stem) && !ys.avoid.includes(STEM_ELEMENT[stem])) {
+      score += 0.15;
+      reasons.push(`天干${stem}为穷通宝鉴次取`);
+    }
+  }
+  let total = Math.round((score + bonus) * 10) / 10;
+  total = Math.max(-4, Math.min(4, total));
+
+  const tier = TIERS.find(([min]) => total >= min)[1];
+  return { ganzhi, score: total, tier, stemTenGod: godStem, reasons, note: `${godStem}运，${tier}（${total}）` };
+}
+
+// ── 对外入口 ────────────────────────────────────────────────
+
+/**
+ * @param {object} p
+ * @param {object} p.pillars 四柱
+ * @param {string} p.dayStem 日干
+ * @param {string} p.monthBranch 月支
+ * @param {object} p.strength bazi.js 的旺衰结果
+ * @param {object} p.wuxing 五行分值
+ */
+function analyzeBaziFrame({ pillars, dayStem, monthBranch, strength, wuxing }) {
+  const gods = godStats(pillars, dayStem);
+  const month = monthPattern(pillars, dayStem, monthBranch);
+  const special = specialPatterns(pillars, dayStem, monthBranch, strength, wuxing, gods);
+  const geju = [month, ...special];
+  const yongshen = yongshenOf(dayStem, monthBranch, strength, wuxing, Object.values(pillars).map((p) => p.branch));
+  return {
+    geju,
+    primary: month,
+    primaryName: month.name,
+    godStats: gods,
+    yongshen,
+    dayStem,
+    monthBranch,
+  };
+}
 
 return { tenGod, elementRoles, tongguanOf, scoreLuck, analyzeBaziFrame };
 })();
 
 __mods.bazi = (function () {
-// 四柱八字引擎
-const { STEMS, BRANCHES, TERM_NAMES, ganzhiName, dayGanzhiIndex, jdToParts, partsToJd, sexagenaryIndex, termWindow, previousJie, nextJie, equationOfTime, formatJd, xunKongOf } = (__mods.calendar || {});
-const { resolveAddress } = (__mods.geo || {});
-const { computeBaziShensha } = (__mods.shensha || {});
-const { assertCivil, daysInMonth } = (__mods.validate || {});
-const { applyDst } = (__mods.dst || {});
-const { nayinOf } = (__mods.nayin || {});
-const { SANHE } = (__mods.sanhe || {});
-const { analyzeBaziFrame, scoreLuck } = (__mods.geju || {});
-
-// 地支藏干（本气 / 中气 / 余气）
-const HIDDEN_STEMS = {
-  子: ['癸'],
-  丑: ['己', '癸', '辛'],
-  寅: ['甲', '丙', '戊'],
-  卯: ['乙'],
-  辰: ['戊', '乙', '癸'],
-  巳: ['丙', '戊', '庚'],
-  午: ['丁', '己'],
-  未: ['己', '丁', '乙'],
-  申: ['庚', '壬', '戊'],
-  酉: ['辛'],
-  戌: ['戊', '辛', '丁'],
-  亥: ['壬', '甲'],
-};
-
-// 人元司权的 30 日表：余气 → 中气 → 本气，按「节」当日起算。
-// 各家对日数分法不一（另有 7/7/16、9/3/18 等），这里固定通行 30 日表；
-// 只作解释层的一层细节，不参与取格。亥月的余气戊不在本柱藏干表中，两表各照原样。
-const RENYUAN_TABLE = {
-  寅: [['戊', 7], ['丙', 7], ['甲', 16]],
-  卯: [['甲', 10], ['乙', 20]],
-  辰: [['乙', 9], ['癸', 3], ['戊', 18]],
-  巳: [['戊', 5], ['庚', 9], ['丙', 16]],
-  午: [['丙', 10], ['己', 9], ['丁', 11]],
-  未: [['丁', 9], ['乙', 3], ['己', 18]],
-  申: [['戊', 7], ['壬', 3], ['庚', 20]],
-  酉: [['庚', 10], ['辛', 20]],
-  戌: [['辛', 9], ['丁', 3], ['戊', 18]],
-  亥: [['戊', 7], ['甲', 5], ['壬', 18]],
-  子: [['壬', 10], ['癸', 20]],
-  丑: [['癸', 9], ['辛', 3], ['己', 18]],
-};
-
-const STEM_ELEMENT = {
-  甲: '木', 乙: '木', 丙: '火', 丁: '火', 戊: '土',
-  己: '土', 庚: '金', 辛: '金', 壬: '水', 癸: '水',
-};
-
-const BRANCH_ELEMENT = {
-  子: '水', 丑: '土', 寅: '木', 卯: '木', 辰: '土', 巳: '火',
-  午: '火', 未: '土', 申: '金', 酉: '金', 戌: '土', 亥: '水',
-};
-
-const GENERATES = { 木: '火', 火: '土', 土: '金', 金: '水', 水: '木' };
-const OVERCOMES = { 木: '土', 土: '水', 水: '火', 火: '金', 金: '木' };
-
-const isYangStem = (stem) => STEMS.indexOf(stem) % 2 === 0;
-
-// 两套藏干权重是不同用途，不是"同一件事写了两次"：
-//   · 五行占比——看这一行在盘里有多少，本气 1 / 中气 0.5 / 余气 0.3；
-//   · 日主通根——看这一支能不能让日主站住，本气权重更高（1.2 / 0.6 / 0.3）。
-const WUXING_HIDDEN_WEIGHT = [1, 0.5, 0.3];
-const ROOT_HIDDEN_WEIGHT = [1.2, 0.6, 0.3];
-
-const STEM_HE = { 甲己: '土', 乙庚: '金', 丙辛: '水', 丁壬: '木', 戊癸: '火' };
-const STEM_CHONG_PAIRS = ['甲庚', '乙辛', '丙壬', '丁癸'];
-const BRANCH_HE = { 子丑: '土', 寅亥: '木', 卯戌: '火', 辰酉: '金', 巳申: '水', 午未: '土' };
-const SANHUI = { 寅卯辰: '木', 巳午未: '火', 申酉戌: '金', 亥子丑: '水' };
-const BRANCH_CHONG = ['子午', '丑未', '寅申', '卯酉', '辰戌', '巳亥'];
-const BRANCH_HAI = ['子未', '丑午', '寅巳', '卯辰', '申亥', '酉戌'];
-const BRANCH_PO = ['子酉', '丑辰', '寅亥', '卯午', '巳申', '未戌'];
-// 三刑：寅巳申（无恩之刑）、丑戌未（恃势之刑）、子卯（无礼之刑）。
-// 另有「自刑」：辰午酉亥四支见同支即自刑（辰辰、午午、酉酉、亥亥），此前漏判。
-const XING_GROUPS = [['寅', '巳', '申'], ['丑', '戌', '未'], ['子', '卯']];
-const XING_SELF = ['辰', '午', '酉', '亥'];
-
-const hasPair = (list, a, b) => list.includes(a + b) || list.includes(b + a);
-
-// 旺衰用的合会折根：三会成方、三合成局时，参与支按化神折去本气；
-// 六合折半；已并入会/合局的支归该局，六合只折局外那一支（否则「巳午未会火 + 午未合土」会把火局自己折掉，
-// 「亥子丑会水 + 寅亥合木」也会把壬日的亥水比劫折半）。
-// 只参与旺衰量化，不改盘面关系列表；半合/半会不折，避免把「有合意」当成「已成局」。
-function branchRootFactors(pillars, me) {
-  const inMe = Object.keys(GENERATES).find((k) => GENERATES[k] === me);
-  const branches = ['year', 'month', 'day', 'hour'].map((k) => pillars[k].branch);
-  const set = new Set(branches);
-  const factor = {};
-  for (const b of branches) factor[b] = 1;
-  const notes = [];
-  const inJu = new Set();
-  const apply = (key, el, f, kind) => {
-    const hit = [];
-    for (const b of [...key]) {
-      if ((factor[b] ?? 1) > f) { factor[b] = f; hit.push(b); }
-      inJu.add(b);
-    }
-    if (hit.length && f < 1) notes.push(`${key}${kind}${el}，${hit.join('')}根气按${Math.round(f * 10)}成计`);
-  };
-  for (const [k, el] of Object.entries(SANHUI)) {
-    if (![...k].every((c) => set.has(c))) continue;
-    apply(k, el, el === me ? 1 : el === inMe ? 0.6 : 0.1, '三会');
-  }
-  for (const [k, el] of Object.entries(SANHE)) {
-    if (![...k].every((c) => set.has(c))) continue;
-    apply(k, el, el === me ? 1 : el === inMe ? 0.6 : 0.2, '三合');
-  }
-  for (let i = 0; i < branches.length; i++) {
-    for (let j = i + 1; j < branches.length; j++) {
-      const a = branches[i];
-      const b = branches[j];
-      const el = BRANCH_HE[a + b] || BRANCH_HE[b + a];
-      if (!el) continue;
-      if (inJu.has(a) && inJu.has(b)) continue;
-      const f = el === me ? 1 : el === inMe ? 0.8 : 0.5;
-      const hit = [];
-      for (const x of [a, b]) {
-        if (inJu.has(x)) continue;
-        if ((factor[x] ?? 1) > f) { factor[x] = f; hit.push(x); }
-      }
-      if (hit.length && f < 1) notes.push(`${a}${b}合${el}，${hit.join('')}根气按${Math.round(f * 10)}成计`);
-    }
-  }
-  return { factor, notes, inJu };
-}
-
-// 天干生扶是否真有根：折根后同类藏干累计 ≥0.3 才算有根（余气 0.3 折半后不足，作虚透）。
-const ROOT_EFFECTIVE_MIN = 0.3;
-function rootedWeightOf(pillars, el, factor) {
-  let w = 0;
-  for (const k of ['year', 'month', 'day', 'hour']) {
-    const pl = pillars[k];
-    const f = factor[pl.branch] ?? 1;
-    if (f <= 0.1) continue;
-    pl.hidden.forEach((h, i) => {
-      if (STEM_ELEMENT[h.stem] === el) w += (ROOT_HIDDEN_WEIGHT[i] ?? 0.1) * f;
-    });
-  }
-  return w;
-}
-
-/** 干支关系：五合、相冲、相克；六合、三合半合、三会半会拱会、冲、害、破、刑 */
-function buildRelations(pillars) {
-  const stems = ['year', 'month', 'day', 'hour'].map((k) => pillars[k].stem);
-  const branches = ['year', 'month', 'day', 'hour'].map((k) => pillars[k].branch);
-
-  const stemOut = [];
-  for (let i = 0; i < 4; i++) {
-    for (let j = i + 1; j < 4; j++) {
-      const a = stems[i];
-      const b = stems[j];
-      if (a === b) continue;
-      const he = STEM_HE[a + b] || STEM_HE[b + a];
-      // 五合只是「有合」；是否真化要看月令、化神与争合妒合，不在这一层断言
-      if (he) { stemOut.push({ text: `${a}${b}合（化${he}待定）`, rank: 0 }); continue; }
-      if (hasPair(STEM_CHONG_PAIRS, a, b)) { stemOut.push({ text: `${a}${b}相冲`, rank: 1 }); continue; }
-      const ea = STEM_ELEMENT[a];
-      const eb = STEM_ELEMENT[b];
-      if (OVERCOMES[ea] === eb) stemOut.push({ text: `${a}克${b}`, rank: 3 });
-      else if (OVERCOMES[eb] === ea) stemOut.push({ text: `${b}克${a}`, rank: 3 });
-    }
-  }
-
-  const branchOut = [];
-  const set = new Set(branches);
-  const fullSans = [];
-  for (const [k, v] of Object.entries(SANHE)) {
-    if ([...k].every((c) => set.has(c))) {
-      branchOut.push({ text: `${k}三合${v}`, rank: 0 });
-      fullSans.push(k);
-    }
-  }
-  const fullHuis = [];
-  for (const [k, v] of Object.entries(SANHUI)) {
-    if ([...k].every((c) => set.has(c))) {
-      branchOut.push({ text: `${k}三会${v}`, rank: 0 });
-      fullHuis.push(k);
-    }
-  }
-  for (let i = 0; i < 4; i++) {
-    for (let j = i + 1; j < 4; j++) {
-      const a = branches[i];
-      const b = branches[j];
-      if (a === b) {
-        // 同支不是"没关系"：辰午酉亥两柱同见为自刑
-        if (XING_SELF.includes(a)) branchOut.push({ text: `${a}${b}自刑`, rank: 2 });
-        continue;
-      }
-      const he = BRANCH_HE[a + b] || BRANCH_HE[b + a];
-      const sh = Object.keys(SANHE).find((k) => k.includes(a) && k.includes(b));
-      const hui = Object.keys(SANHUI).find((k) => k.includes(a) && k.includes(b));
-      if (he) {
-        // 六合优先，不再重复标半合/半会
-        branchOut.push({ text: `${a}${b}合${he}`, rank: 0 });
-      } else {
-        if (sh && !fullSans.includes(sh)) {
-          const mid = sh[1];
-          const kind = a === mid || b === mid ? '半合' : '拱合';
-          branchOut.push({ text: `${a}${b}${kind}${SANHE[sh]}`, rank: 0 });
-        }
-        if (hui && !fullHuis.includes(hui)) {
-          const adj = Math.abs(hui.indexOf(a) - hui.indexOf(b)) === 1;
-          branchOut.push({ text: `${a}${b}${adj ? '半会' : '拱会'}${SANHUI[hui]}`, rank: 0 });
-        }
-      }
-      if (hasPair(BRANCH_CHONG, a, b)) branchOut.push({ text: `${a}${b}相冲`, rank: 1 });
-      if (hasPair(BRANCH_HAI, a, b)) branchOut.push({ text: `${a}${b}相害`, rank: 2 });
-      if (hasPair(BRANCH_PO, a, b)) branchOut.push({ text: `${a}${b}相破`, rank: 2 });
-      for (const g of XING_GROUPS) {
-        if (g.includes(a) && g.includes(b)) branchOut.push({ text: `${a}${b}相刑`, rank: 2 });
-      }
-    }
-  }
-
-  const uniq = (arr) => {
-    const seen = new Set();
-    const out = [];
-    for (const x of [...arr].sort((p, q) => p.rank - q.rank)) {
-      if (!seen.has(x.text)) { seen.add(x.text); out.push(x.text); }
-    }
-    return out;
-  };
-  return { stems: uniq(stemOut), branches: uniq(branchOut) };
-}
-
-/** 十神：以日干为我 */
-function tenGod(dayStem, otherStem) {
-  const me = STEM_ELEMENT[dayStem];
-  const it = STEM_ELEMENT[otherStem];
-  const samePolarity = isYangStem(dayStem) === isYangStem(otherStem);
-  if (me === it) return samePolarity ? '比肩' : '劫财';
-  if (GENERATES[me] === it) return samePolarity ? '食神' : '伤官';
-  if (OVERCOMES[me] === it) return samePolarity ? '偏财' : '正财';
-  if (OVERCOMES[it] === me) return samePolarity ? '七杀' : '正官';
-  if (GENERATES[it] === me) return samePolarity ? '偏印' : '正印';
-  return '?';
-}
-
-function nayin(ganzhiIdx) {
-  return nayinOf(ganzhiIdx).name;
-}
-
-const JIE_TO_MONTH_BRANCH = { 0: 1, 2: 2, 4: 3, 6: 4, 8: 5, 10: 6, 12: 7, 14: 8, 16: 9, 18: 10, 20: 11, 22: 0 };
-
-function pillar(ganzhiIdx, dayStem) {
-  const g = ganzhiName(ganzhiIdx);
-  const hidden = HIDDEN_STEMS[g.branch];
-  return {
-    ganzhi: g.name,
-    stem: g.stem,
-    branch: g.branch,
-    stemElement: STEM_ELEMENT[g.stem],
-    branchElement: BRANCH_ELEMENT[g.branch],
-    stemTenGod: dayStem ? tenGod(dayStem, g.stem) : null,
-    hidden: hidden.map((s, i) => ({
-      stem: s,
-      element: STEM_ELEMENT[s],
-      tenGod: dayStem ? tenGod(dayStem, s) : null,
-      role: ['本气', '中气', '余气'][i] ?? '余气',
-    })),
-    nayin: nayin(ganzhiIdx),
-  };
-}
-
-/**
- * 真太阳时修正
- * @returns {{offsetMinutes:number, jd:number, note:string}}
- */
-function applyTrueSolar(jd, longitude) {
-  const p = jdToParts(jd);
-  if (longitude == null || Number.isNaN(longitude)) {
-    return { offsetMinutes: 0, jd, note: '未提供经度，按东八区平太阳时' };
-  }
-  const longitudeMinutes = (longitude - 120) * 4;
-  const eot = equationOfTime(p.year, p.month, p.day);
-  const offset = longitudeMinutes + eot;
-  return {
-    offsetMinutes: Math.round(offset * 10) / 10,
-    jd: jd + offset / 1440,
-    note: `经度差 ${longitudeMinutes.toFixed(1)} 分 + 均时差 ${eot.toFixed(1)} 分`,
-  };
-}
-
-/**
- * 人元司权：生在本月第几日、哪一藏干当权。
- * 日数按「节令日」与出生日的日差计，节当日为第 1 日；固定 30 日表，
- * 第 31 日以后不再硬分摊，按本气算并标 beyond。
- * @param {string} monthBranch 月支（寅…丑）
- * @param {number} birthJdn 出生日的儒略日数（含真太阳时修正后的日）
- * @param {number} termJd 本月「节」的儒略日
- */
-function renyuanOf(monthBranch, birthJdn, termJd) {
-  const table = RENYUAN_TABLE[monthBranch];
-  if (!table) return null;
-  const segments = [];
-  let from = 1;
-  for (const [stem, days] of table) {
-    segments.push({ stem, element: STEM_ELEMENT[stem], from, to: from + days - 1 });
-    from += days;
-  }
-  const tableDays = from - 1;
-  const day = Math.max(1, Math.floor(birthJdn) - Math.floor(termJd + 0.5) + 1);
-  const beyond = day > tableDays;
-  const idx = beyond ? segments.length - 1 : segments.findIndex((s) => day >= s.from && day <= s.to);
-  const seg = segments[idx] || segments[segments.length - 1];
-  const next = segments[idx + 1] || null;
-  return {
-    month: monthBranch,
-    day,
-    tableDays,
-    segments,
-    active: seg.stem,
-    activeElement: seg.element,
-    segment: { from: seg.from, to: seg.to },
-    next: next ? { stem: next.stem, element: next.element, from: next.from, inDays: next.from - day } : null,
-    // 司权表与本柱藏干表口径不同：亥月的余气戊只出现在司权表里
-    inHidden: (HIDDEN_STEMS[monthBranch] || []).includes(seg.stem),
-    beyond,
-    note: '人元司权按「节」当日起算，节当日为第 1 日，日差用本盘所用时刻（含真太阳时）所在日计；本插件固定 30 日表（余气 → 中气 → 本气），第 31 日以后按本气算。只作解释层的一层细节，不改取格。',
-  };
-}
-
-/**
- * 排四柱八字
- * @param {object} input { year,month,day,hour,minute, gender:'male'|'female', longitude?, lateZi?:boolean, trueSolar?:boolean }
- */
-function buildBazi(input) {
-  assertCivil(input);
-  let { year, month, day, hour = 0, minute = 0, gender = 'male' } = input;
-  const lateZi = input.lateZi !== false;
-  const useTrueSolar = input.trueSolar !== false;
-  // 1986–1991 中国夏令时：出生证钟面时间普遍是「拨快 1 小时」的钟面时间，
-  // 不校正会让时柱（乃至跨 23:00 的日柱）整档偏；显式传 dst:false 可关闭。
-  const dst = input.dst === false ? { applied: false, note: null } : applyDst({ year, month, day, hour, minute });
-  if (dst.applied) {
-    year = dst.year; month = dst.month; day = dst.day; hour = dst.hour; minute = dst.minute;
-  }
-
-  const civilJd = partsToJd({ year, month, day, hour, minute });
-  // 地址 -> 经度：手填的 longitude 优先，其次按地址查表
-  const geo = input.geo || (input.address ? resolveAddress(input.address) : null);
-  const longitude = typeof input.longitude === 'number'
-    ? input.longitude
-    : (geo && typeof geo.lon === 'number' ? geo.lon : undefined);
-  const solar = useTrueSolar ? applyTrueSolar(civilJd, longitude) : { offsetMinutes: 0, jd: civilJd, note: '未启用真太阳时' };
-  const jd = solar.jd;
-
-  // 八字只用「节」定月柱与起运（气不参与），传 jieOnly 省掉一半节气求值
-  const terms = termWindow(year, { jieOnly: true });
-  const prevJieTerm = previousJie(terms, jd);
-  const nextJieTerm = nextJie(terms, jd);
-
-  // 年柱：以立春为界
-  const lichun = terms.find((t) => t.index === 2 && t.year === year);
-  const solarYear = lichun && jd < lichun.jd ? year - 1 : year;
-  const yearIdx = (((solarYear - 4) % 60) + 60) % 60;
-  const yearStem = STEMS[yearIdx % 10];
-
-  // 月柱：以「节」为界
-  const monthBranchIdx = JIE_TO_MONTH_BRANCH[prevJieTerm.index];
-  const yinMonthStem = ((STEMS.indexOf(yearStem) % 5) * 2 + 2) % 10;
-  const monthOffset = ((monthBranchIdx - 2) % 12 + 12) % 12; // 0 = 寅月
-  const monthStemIdx = (yinMonthStem + monthOffset) % 10;
-  const monthIdx = sexagenaryIndex(monthStemIdx, monthBranchIdx);
-
-  // 日柱：23:00 后是否换日
-  const jdnBase = Math.floor(jd + 0.5);
-  const hourOfDay = jdToParts(jd).hour;
-  const jdn = lateZi && hourOfDay >= 23 ? jdnBase + 1 : jdnBase;
-  const dayIdx = dayGanzhiIndex(jdn);
-  const dayStem = STEMS[dayIdx % 10];
-
-  // 时柱：五鼠遁
-  const hourBranchIdx = Math.floor(((hourOfDay + 1) % 24) / 2);
-  const ziHourStem = ((STEMS.indexOf(dayStem) % 5) * 2) % 10;
-  const hourStemIdx = (ziHourStem + hourBranchIdx) % 10;
-  const hourIdx = sexagenaryIndex(hourStemIdx, hourBranchIdx);
-
-  const pillars = {
-    year: pillar(yearIdx, dayStem),
-    month: pillar(monthIdx, dayStem),
-    day: pillar(dayIdx, dayStem),
-    hour: pillar(hourIdx, dayStem),
-  };
-
-  // 大运
-  const isYangYear = STEMS.indexOf(yearStem) % 2 === 0;
-  const forward = (isYangYear && gender === 'male') || (!isYangYear && gender === 'female');
-  const spanDays = forward ? nextJieTerm.jd - jd : jd - prevJieTerm.jd;
-  const totalMonths = spanDays * 4; // 3 天 = 1 年 = 12 个月
-  let startAgeYears = Math.floor(totalMonths / 12);
-  let startAgeMonths = Math.round(totalMonths % 12);
-  // 四舍五入到 12 个月时必须进位，否则显示「X 岁 12 个月起运」
-  if (startAgeMonths >= 12) { startAgeMonths -= 12; startAgeYears += 1; }
-
-  // 交运：三日折一年。
-  // 古法三条换算是同一比例的三种说法——3 日折 1 年、1 日折 4 个月、1 时辰折 10 日：
-  // 把「出生 → 起运那一侧的节令」的真实间隔按 365.2422/3（≈121.7474）倍放大，
-  // 就是起运那一刻；放大后的 1/12 恰好 121.7474/12 ≈ 10.15 天，即「一时辰十日」。
-  // 一年取回归年 365.2422 日（交运日细算各家不一，这里固定这一个口径并写明）。
-  const JIAO_YEAR_DAYS = 365.2422;
-  const JIAO_SCALE = JIAO_YEAR_DAYS / 3;
-  const jiaoFromTerm = forward ? nextJieTerm : prevJieTerm;
-  const jiaoJd = jd + spanDays * JIAO_SCALE;
-  const jiaoParts = jdToParts(jiaoJd);
-  // 每步大运在「同月同日同时刻」换；公历闰日（2 月 29 日生）退到 2 月 28 日
-  const addYearsClamped = (p, n) => {
-    const y = p.year + n;
-    return { year: y, month: p.month, day: Math.min(p.day, daysInMonth(y, p.month)), hour: p.hour, minute: p.minute };
-  };
-
-  const dayun = [];
-  const dayunWindows = [];
-  for (let i = 1; i <= 8; i++) {
-    const idx = (((monthIdx + (forward ? i : -i)) % 60) + 60) % 60;
-    const g = ganzhiName(idx);
-    const fromJd = partsToJd(addYearsClamped(jiaoParts, (i - 1) * 10));
-    const toJd = partsToJd(addYearsClamped(jiaoParts, i * 10));
-    dayun.push({
-      step: i,
-      startAge: startAgeYears + (i - 1) * 10,
-      ganzhi: g.name,
-      stem: g.stem,
-      branch: g.branch,
-      stemTenGod: tenGod(dayStem, g.stem),
-      nayin: nayin(idx),
-      // 这一步大运的起止交运时刻（与摘要/面板同源，可直接拿来对年表）
-      fromDate: formatJd(fromJd),
-      toDate: formatJd(toJd),
-    });
-    dayunWindows.push({ step: i, ganzhi: g.name, fromJd, toJd });
-  }
-
-  // 流年（默认从「今年」起排 10 年；传 input.nowYear 可钉死基准年，用于复现历史结论）
-  const thisYear = Number(input.nowYear) || new Date().getFullYear();
-  const liunian = [];
-  for (let y = thisYear; y < thisYear + 10; y++) {
-    const idx = (((y - 4) % 60) + 60) % 60;
-    liunian.push({
-      year: y,
-      age: y - solarYear + 1,
-      ganzhi: ganzhiName(idx).name,
-      stemTenGod: tenGod(dayStem, ganzhiName(idx).stem),
-    });
-  }
-
-  // 五行统计（天干 1.0；地支藏干按 WUXING_HIDDEN_WEIGHT）
-  const wuxing = { 木: 0, 火: 0, 土: 0, 金: 0, 水: 0 };
-  for (const p of Object.values(pillars)) {
-    wuxing[p.stemElement] += 1;
-    p.hidden.forEach((h, i) => {
-      wuxing[h.element] += WUXING_HIDDEN_WEIGHT[i] ?? 0.1;
-    });
-  }
-  for (const k of Object.keys(wuxing)) wuxing[k] = Math.round(wuxing[k] * 10) / 10;
-
-  // 旬空（以日柱所在旬）
-  const xunStart = Math.floor(dayIdx / 10) * 10;
-  const kongwang = [
-    BRANCHES[(xunStart + 10) % 12],
-    BRANCHES[(xunStart + 11) % 12],
-  ];
-
-  // ── 十二长生、各柱空亡、神煞 ──────────────────────────────
-  const CHANGSHENG = ['长生', '沐浴', '冠带', '临官', '帝旺', '衰', '病', '死', '墓', '绝', '胎', '养'];
-  const CS_START = { 甲: 11, 乙: 6, 丙: 2, 丁: 9, 戊: 2, 己: 9, 庚: 5, 辛: 0, 壬: 8, 癸: 3 };
-  const isYang = (s) => STEMS.indexOf(s) % 2 === 0;
-
-  function changsheng(stem, branch) {
-    const start = CS_START[stem];
-    const bi = BRANCHES.indexOf(branch);
-    const step = isYang(stem) ? bi - start : start - bi;
-    return CHANGSHENG[((step % 12) + 12) % 12];
-  }
-
-  // 旬空统一走 calendar.xunKongOf：此前 bazi / liuyao / daliuren 各写一份公式，
-  // 三份形式不同（一处用 (start+10)%12、一处用 (10-2k)%12、一处查表），改一处极易漏改另两处。
-  const monthBranch = pillars.month.branch;
-
-  // 神煞：表驱动、双查法（年干/日干、年支/日支、月支、日柱、时柱），详见 engine/shensha.js
-  const shensha = computeBaziShensha(pillars, kongwang);
-
-  for (const key of ['year', 'month', 'day', 'hour']) {
-    const pl = pillars[key];
-    pl.dishi = changsheng(dayStem, pl.branch);
-    pl.zizuo = changsheng(pl.stem, pl.branch);
-    pl.kongwang = xunKongOf(pl.ganzhi);
-    // shensha 保持字符串数组以兼容既有 UI / 测试；明细见 shenshaDetail
-    pl.shensha = shensha.detail[key].map((x) => x.name);
-    pl.shenshaDetail = shensha.detail[key];
-  }
-
-  // ── 日主旺衰（月令 + 通根 + 天干帮扶，量化但规则透明）──
-  const SEASON_EL = { 寅: '木', 卯: '木', 巳: '火', 午: '火', 申: '金', 酉: '金', 亥: '水', 子: '水', 辰: '土', 戌: '土', 丑: '土', 未: '土' };
-  const me = STEM_ELEMENT[dayStem];
-  const seasonEl = SEASON_EL[monthBranch];
-  let monthW;
-  let monthWord;
-  if (me === seasonEl) { monthW = 3; monthWord = '旺'; }
-  else if (GENERATES[seasonEl] === me) { monthW = 2; monthWord = '相'; }
-  else if (GENERATES[me] === seasonEl) { monthW = 1; monthWord = '休'; }
-  else if (OVERCOMES[me] === seasonEl) { monthW = 0.5; monthWord = '囚'; }
-  else { monthW = 0; monthWord = '死'; }
-
-  const factorInfo = branchRootFactors(pillars, me);
-  let rootScore = 0;
-  const rootBranches = [];
-  for (const key of ['year', 'month', 'day', 'hour']) {
-    const pl = pillars[key];
-    const f = factorInfo.factor[pl.branch] ?? 1;
-    let hit = false;
-    pl.hidden.forEach((h, i) => {
-      if (STEM_ELEMENT[h.stem] === me) { rootScore += (ROOT_HIDDEN_WEIGHT[i] ?? 0.1) * f; hit = true; }
-      else if (GENERATES[STEM_ELEMENT[h.stem]] === me) { rootScore += (ROOT_HIDDEN_WEIGHT[i] ?? 0.1) * 0.4 * f; hit = true; }
-    });
-    if (hit) rootBranches.push(pl.branch);
-  }
-
-  let helpScore = 0;
-  const helpers = [];
-  const drainers = [];
-  const virtualHelpers = [];
-  for (const key of ['year', 'month', 'hour']) {
-    const st = pillars[key].stem;
-    const el2 = STEM_ELEMENT[st];
-    if (el2 === me || GENERATES[el2] === me) {
-      // 天干有根才出得上力；虚透（折根后不足 0.3）只按半力计
-      const base = el2 === me ? 1 : 0.8;
-      if (rootedWeightOf(pillars, el2, factorInfo.factor) >= ROOT_EFFECTIVE_MIN) helpScore += base;
-      else { helpScore += base * 0.5; virtualHelpers.push(st); }
-      helpers.push(st);
-    } else if (OVERCOMES[el2] === me) { helpScore -= 1; drainers.push(st); }
-    else if (OVERCOMES[me] === el2) { helpScore -= 0.8; drainers.push(st); }
-    else { helpScore -= 0.5; drainers.push(st); }
-  }
-
-  const total = Math.round((monthW + rootScore + helpScore) * 10) / 10;
-  const level = total >= 4 ? '身强' : total >= 2.5 ? '偏强' : total >= 1.5 ? '中和' : total >= 0.5 ? '偏弱' : '身弱';
-  const structureText = factorInfo.notes.length ? `；合会折根：${factorInfo.notes.join('、')}` : '';
-  const virtualText = virtualHelpers.length ? `；虚透${virtualHelpers.join('')}帮扶减半` : '';
-  const strength = {
-    level,
-    score: total,
-    detail: `月令${monthBranch}${seasonEl}，日主${me}${monthWord}(${monthW})；通根${rootBranches.join('') || '无'}(${rootScore.toFixed(1)})；天干帮扶${helpers.join('') || '无'}／耗泄${drainers.join('') || '无'}(${helpScore.toFixed(1)})${structureText}${virtualText}`,
-    method: '月令权重 3/2/1/0.5/0 + 地支藏干通根（三会/三合/六合折根）+ 天干帮扶（虚透减半），量化后分档；属简化算法，非唯一流派',
-    parts: {
-      season: { branch: monthBranch, element: seasonEl, word: monthWord, weight: monthW },
-      roots: rootBranches,
-      rootScore: Math.round(rootScore * 10) / 10,
-      helpers,
-      drainers,
-      helpScore: Math.round(helpScore * 10) / 10,
-      structure: factorInfo.notes,
-      virtualHelpers,
-    },
-  };
-
-  // ── 格局 / 用神 / 行运 ─────────────────────────────────────
-  const frame = analyzeBaziFrame({ pillars, dayStem, monthBranch, strength, wuxing });
-
-  // ── 大运/流年与原局的地支关系 ──
-  const pairRel = (a, b) => {
-    if (!a || !b) return [];
-    // 大运/流年支与原局同支：辰午酉亥为自刑，其余同支不算关系
-    if (a === b) return XING_SELF.includes(a) ? ['自刑'] : [];
-    const out = [];
-    if (BRANCH_HE[a + b] || BRANCH_HE[b + a]) out.push('合');
-    if (hasPair(BRANCH_CHONG, a, b)) out.push('冲');
-    if (hasPair(BRANCH_HAI, a, b)) out.push('害');
-    if (hasPair(BRANCH_PO, a, b)) out.push('破');
-    for (const g of XING_GROUPS) if (g.includes(a) && g.includes(b)) out.push('刑');
-    return out;
-  };
-  const natalBranches = ['year', 'month', 'day', 'hour'].map((k) => pillars[k].branch);
-  const relOf = (branch) => {
-    const seen = new Set();
-    const out = [];
-    for (const b of natalBranches) {
-      for (const r of pairRel(b, branch)) {
-        const t = r + b;
-        if (!seen.has(t)) { seen.add(t); out.push(t); }
-      }
-    }
-    return out;
-  };
-  for (const d of dayun) {
-    d.relations = relOf(d.branch);
-    d.luck = scoreLuck(d.ganzhi, frame);
-  }
-  for (const l of liunian) {
-    l.relations = relOf(l.ganzhi[1]);
-    l.luck = scoreLuck(l.ganzhi, frame);
-  }
-
-  // ── 岁运并临 / 伏吟反吟：只标干支层面的「变动信号」，不判吉凶 ──
-  // 流年按立春起算（该年立春到次年立春），当值大运取与这一区间相交的步；
-  // 交运落在这一年里时，前后两步都在本年当过值，两条都列出。
-  const NATAL_LABEL = { year: '年柱', month: '月柱', day: '日柱', hour: '时柱' };
-  const stemOvercomes = (a, b) => OVERCOMES[STEM_ELEMENT[a]] === STEM_ELEMENT[b];
-  const tianKeDiChong = (a, b) => {
-    if (typeof a !== 'string' || typeof b !== 'string' || a.length < 2 || b.length < 2) return false;
-    if (!(a[0] in STEM_ELEMENT) || !(b[0] in STEM_ELEMENT)) return false;
-    return (stemOvercomes(a[0], b[0]) || stemOvercomes(b[0], a[0])) && hasPair(BRANCH_CHONG, a[1], b[1]);
-  };
-  const lichunJd = (y) => {
-    const t = termWindow(y, { jieOnly: true }).find((x) => x.index === 2 && jdToParts(x.jd).year === y);
-    return t ? t.jd : partsToJd({ year: y, month: 2, day: 4 });
-  };
-  for (const l of liunian) {
-    const yStart = lichunJd(l.year);
-    const yEnd = lichunJd(l.year + 1);
-    const active = dayunWindows.filter((w) => w.fromJd < yEnd && w.toJd > yStart);
-    const signals = [];
-    for (const w of active) {
-      if (w.ganzhi === l.ganzhi) {
-        signals.push({ type: '岁运并临', target: `第${w.step}步大运`, detail: `大运与流年同为${l.ganzhi}` });
-      } else if (tianKeDiChong(w.ganzhi, l.ganzhi)) {
-        signals.push({ type: '运年反吟', target: `第${w.step}步大运`, detail: `大运${w.ganzhi}与流年${l.ganzhi}天克地冲` });
-      }
-      // 大运与本命四柱的伏吟/反吟：整步大运都在，逐年列出，不按流年另算一次
-      for (const key of ['year', 'month', 'day', 'hour']) {
-        const g = pillars[key].ganzhi;
-        if (!g) continue;
-        if (w.ganzhi === g) {
-          signals.push({ type: '大运伏吟', target: `第${w.step}步大运·${NATAL_LABEL[key]}`, detail: `大运${w.ganzhi}与${NATAL_LABEL[key]}同干支` });
-        } else if (tianKeDiChong(w.ganzhi, g)) {
-          signals.push({ type: '大运反吟', target: `第${w.step}步大运·${NATAL_LABEL[key]}`, detail: `大运${w.ganzhi}与${NATAL_LABEL[key]}${g}天克地冲` });
-        }
-      }
-    }
-    for (const key of ['year', 'month', 'day', 'hour']) {
-      const g = pillars[key].ganzhi;
-      if (!g) continue;
-      if (l.ganzhi === g) {
-        signals.push({ type: '流年伏吟', target: NATAL_LABEL[key], detail: `流年${l.ganzhi}与${NATAL_LABEL[key]}同干支` });
-      } else if (tianKeDiChong(l.ganzhi, g)) {
-        signals.push({ type: '流年反吟', target: NATAL_LABEL[key], detail: `流年${l.ganzhi}与${NATAL_LABEL[key]}${g}天克地冲` });
-      }
-    }
-    l.suiyun = {
-      dayun: active.map((w) => ({ step: w.step, ganzhi: w.ganzhi })),
-      signals,
-      note: '只标干支重复与天克地冲这类变动信号，不判吉凶；大运按该年立春到次年立春的区间取，交运落在年内时前后两步并列；大运与本命四柱的伏吟/反吟整步大运都在，逐年重复列出',
-    };
-  }
-
-  const p = jdToParts(jd);
-
-  // ── 胎元 / 胎息 / 命宫 / 身宫 ──
-  // 胎元：月柱天干进一位、地支进三位（受胎之月的干支）
-  const mStemIdx = STEMS.indexOf(pillars.month.stem);
-  const mBranchIdx = BRANCHES.indexOf(pillars.month.branch);
-  const taiyuan = ganzhiName(sexagenaryIndex((mStemIdx + 1) % 10, (mBranchIdx + 3) % 12));
-  // 胎息：日柱天干五合、地支六合（六合两支序数之和恒为 1 mod 12）
-  const dayStemIdx = STEMS.indexOf(pillars.day.stem);
-  const dayBranchIdx = BRANCHES.indexOf(pillars.day.branch);
-  const taixi = ganzhiName(sexagenaryIndex((dayStemIdx + 5) % 10, (1 - dayBranchIdx + 12) % 12));
-  // 命宫 / 身宫：以生月、生时两支的合数定宫（Tyme 口径）。
-  // 命宫：27 − 月支 − 时支，取模后 +2；身宫：11 + 月支 + 时支，取模后 +2。
-  // 两支合数落 0–11 后并入六十甲子，天干随年干自然对齐，无需另推五虎遁。
-  const hourBrIdxForGong = BRANCHES.indexOf(pillars.hour.branch);
-  const yearStemIdxForGong = STEMS.indexOf(pillars.year.stem);
-  const mingIdx = (((yearStemIdxForGong * 12 + ((27 - mBranchIdx - hourBrIdxForGong) % 12) + 2) % 60) + 60) % 60;
-  const bodyIdx = (((yearStemIdxForGong * 12 + ((11 + mBranchIdx + hourBrIdxForGong) % 12) + 2) % 60) + 60) % 60;
-  const minggong = ganzhiName(mingIdx);
-  const shengong = ganzhiName(bodyIdx);
-
-  // 人元司权：按节令到出生日的日差定当权藏干（节当日为第 1 日）
-  const renyuan = renyuanOf(BRANCHES[monthBranchIdx], jdnBase, prevJieTerm.jd);
-  if (renyuan) renyuan.term = { name: prevJieTerm.name, time: formatJd(prevJieTerm.jd) };
-
-  return {
-    system: 'bazi',
-    relations: buildRelations(pillars),
-    palaces: {
-      taiyuan: { ganzhi: taiyuan.name, note: '月干进一、月支进三' },
-      taixi: { ganzhi: taixi.name, note: '日干五合、日支六合' },
-      minggong: { ganzhi: minggong.name, branch: minggong.branch, note: '生月与生时支合数定宫（27 减，取模后 +2）；干随六十甲子' },
-      shengong: { ganzhi: shengong.name, branch: shengong.branch, note: '生月与生时支合数定宫（11 加，取模后 +2）；干随六十甲子' },
-    },
-    input: {
-      civil: { year, month, day, hour, minute },
-      gender,
-      longitude: longitude ?? null,
-      address: input.address || null,
-      geo,
-      lateZi,
-      trueSolar: useTrueSolar,
-      dst: { applied: !!dst.applied, note: dst.note || null },
-    },
-    solarTime: {
-      civilText: `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')} ${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`,
-      trueSolarText: formatJd(jd),
-      offsetMinutes: solar.offsetMinutes,
-      note: dst.applied ? `${dst.note}；${solar.note}` : solar.note,
-      lunarYearForPillar: solarYear,
-    },
-    jieqi: {
-      previous: { name: prevJieTerm.name, time: formatJd(prevJieTerm.jd) },
-      next: { name: nextJieTerm.name, time: formatJd(nextJieTerm.jd) },
-      // 距「节」的分钟数（取两侧较小值）。是否提示复核由摘要层决定，阈值 20 分钟：
-      // 与 NAOJ 历要项对拍实测节气最多偏 13.5 分钟，20 分钟留出余量。
-      nearBoundaryMinutes: Math.round(Math.min(jd - prevJieTerm.jd, nextJieTerm.jd - jd) * 1440),
-    },
-    renyuan,
-    pillars,
-    dayMaster: { stem: dayStem, element: STEM_ELEMENT[dayStem], yinYang: isYangStem(dayStem) ? '阳' : '阴' },
-    wuxing,
-    kongwang,
-    shensha,
-    dayun: {
-      direction: forward ? '顺行' : '逆行',
-      rule: `${isYangYear ? '阳' : '阴'}年${gender === 'male' ? '男' : '女'}${forward ? '顺排' : '逆排'}`,
-      startAge: { years: startAgeYears, months: startAgeMonths },
-      toNextJieDays: Math.round(spanDays * 100) / 100,
-      // 交运时刻（日/时辰级）：上方 startAge 是四舍五入到月的旧字段，两者同源、不互相覆盖
-      jiao: {
-        at: formatJd(jiaoJd),
-        jd: Math.round(jiaoJd * 1e6) / 1e6,
-        scaleDaysPerDay: JIAO_SCALE,
-        yearDays: JIAO_YEAR_DAYS,
-        spanDays: Math.round(spanDays * 1e4) / 1e4,
-        from: { name: jiaoFromTerm.name, time: formatJd(jiaoFromTerm.jd) },
-        frame: solar.offsetMinutes ? '真太阳时' : '平太阳时',
-        offsetMinutes: solar.offsetMinutes,
-        note: '三日折一年：出生到节令的真实间隔按 365.2422/3 放大后加到出生时刻；同一比例即「一日折四月、一时辰折十日」，每步大运在同月同日同时刻换',
-      },
-      list: dayun,
-    },
-    strength,
-    frame,
-    climate: frame.yongshen.climate || frame.yongshen.tiaohou || null,
-    liunian,
-    liunianFrom: thisYear,
-  };
-}
+// 四柱八字引擎
+const { STEMS, BRANCHES, TERM_NAMES, ganzhiName, dayGanzhiIndex, jdToParts, partsToJd, sexagenaryIndex, termWindow, previousJie, nextJie, equationOfTime, formatJd, xunKongOf } = (__mods.calendar || {});
+const { resolveAddress } = (__mods.geo || {});
+const { computeBaziShensha } = (__mods.shensha || {});
+const { assertCivil, daysInMonth } = (__mods.validate || {});
+const { applyDst } = (__mods.dst || {});
+const { nayinOf } = (__mods.nayin || {});
+const { SANHE } = (__mods.sanhe || {});
+const { analyzeBaziFrame, scoreLuck } = (__mods.geju || {});
+
+// 地支藏干（本气 / 中气 / 余气）
+const HIDDEN_STEMS = {
+  子: ['癸'],
+  丑: ['己', '癸', '辛'],
+  寅: ['甲', '丙', '戊'],
+  卯: ['乙'],
+  辰: ['戊', '乙', '癸'],
+  巳: ['丙', '戊', '庚'],
+  午: ['丁', '己'],
+  未: ['己', '丁', '乙'],
+  申: ['庚', '壬', '戊'],
+  酉: ['辛'],
+  戌: ['戊', '辛', '丁'],
+  亥: ['壬', '甲'],
+};
+
+// 人元司权的 30 日表：余气 → 中气 → 本气，按「节」当日起算。
+// 各家对日数分法不一（另有 7/7/16、9/3/18 等），这里固定通行 30 日表；
+// 只作解释层的一层细节，不参与取格。亥月的余气戊不在本柱藏干表中，两表各照原样。
+const RENYUAN_TABLE = {
+  寅: [['戊', 7], ['丙', 7], ['甲', 16]],
+  卯: [['甲', 10], ['乙', 20]],
+  辰: [['乙', 9], ['癸', 3], ['戊', 18]],
+  巳: [['戊', 5], ['庚', 9], ['丙', 16]],
+  午: [['丙', 10], ['己', 9], ['丁', 11]],
+  未: [['丁', 9], ['乙', 3], ['己', 18]],
+  申: [['戊', 7], ['壬', 3], ['庚', 20]],
+  酉: [['庚', 10], ['辛', 20]],
+  戌: [['辛', 9], ['丁', 3], ['戊', 18]],
+  亥: [['戊', 7], ['甲', 5], ['壬', 18]],
+  子: [['壬', 10], ['癸', 20]],
+  丑: [['癸', 9], ['辛', 3], ['己', 18]],
+};
+
+const STEM_ELEMENT = {
+  甲: '木', 乙: '木', 丙: '火', 丁: '火', 戊: '土',
+  己: '土', 庚: '金', 辛: '金', 壬: '水', 癸: '水',
+};
+
+const BRANCH_ELEMENT = {
+  子: '水', 丑: '土', 寅: '木', 卯: '木', 辰: '土', 巳: '火',
+  午: '火', 未: '土', 申: '金', 酉: '金', 戌: '土', 亥: '水',
+};
+
+const GENERATES = { 木: '火', 火: '土', 土: '金', 金: '水', 水: '木' };
+const OVERCOMES = { 木: '土', 土: '水', 水: '火', 火: '金', 金: '木' };
+
+const isYangStem = (stem) => STEMS.indexOf(stem) % 2 === 0;
+
+// 两套藏干权重是不同用途，不是"同一件事写了两次"：
+//   · 五行占比——看这一行在盘里有多少，本气 1 / 中气 0.5 / 余气 0.3；
+//   · 日主通根——看这一支能不能让日主站住，本气权重更高（1.2 / 0.6 / 0.3）。
+const WUXING_HIDDEN_WEIGHT = [1, 0.5, 0.3];
+const ROOT_HIDDEN_WEIGHT = [1.2, 0.6, 0.3];
+
+const STEM_HE = { 甲己: '土', 乙庚: '金', 丙辛: '水', 丁壬: '木', 戊癸: '火' };
+const STEM_CHONG_PAIRS = ['甲庚', '乙辛', '丙壬', '丁癸'];
+const BRANCH_HE = { 子丑: '土', 寅亥: '木', 卯戌: '火', 辰酉: '金', 巳申: '水', 午未: '土' };
+const SANHUI = { 寅卯辰: '木', 巳午未: '火', 申酉戌: '金', 亥子丑: '水' };
+const BRANCH_CHONG = ['子午', '丑未', '寅申', '卯酉', '辰戌', '巳亥'];
+const BRANCH_HAI = ['子未', '丑午', '寅巳', '卯辰', '申亥', '酉戌'];
+const BRANCH_PO = ['子酉', '丑辰', '寅亥', '卯午', '巳申', '未戌'];
+// 三刑：寅巳申（无恩之刑）、丑戌未（恃势之刑）、子卯（无礼之刑）。
+// 另有「自刑」：辰午酉亥四支见同支即自刑（辰辰、午午、酉酉、亥亥），此前漏判。
+const XING_GROUPS = [['寅', '巳', '申'], ['丑', '戌', '未'], ['子', '卯']];
+const XING_SELF = ['辰', '午', '酉', '亥'];
+
+const hasPair = (list, a, b) => list.includes(a + b) || list.includes(b + a);
+
+// 旺衰用的合会折根：三会成方、三合成局时，参与支按化神折去本气；
+// 六合折半；已并入会/合局的支归该局，六合只折局外那一支（否则「巳午未会火 + 午未合土」会把火局自己折掉，
+// 「亥子丑会水 + 寅亥合木」也会把壬日的亥水比劫折半）。
+// 只参与旺衰量化，不改盘面关系列表；半合/半会不折，避免把「有合意」当成「已成局」。
+function branchRootFactors(pillars, me) {
+  const inMe = Object.keys(GENERATES).find((k) => GENERATES[k] === me);
+  const branches = ['year', 'month', 'day', 'hour'].map((k) => pillars[k].branch);
+  const set = new Set(branches);
+  const factor = {};
+  for (const b of branches) factor[b] = 1;
+  const notes = [];
+  const inJu = new Set();
+  const apply = (key, el, f, kind) => {
+    const hit = [];
+    for (const b of [...key]) {
+      if ((factor[b] ?? 1) > f) { factor[b] = f; hit.push(b); }
+      inJu.add(b);
+    }
+    if (hit.length && f < 1) notes.push(`${key}${kind}${el}，${hit.join('')}根气按${Math.round(f * 10)}成计`);
+  };
+  for (const [k, el] of Object.entries(SANHUI)) {
+    if (![...k].every((c) => set.has(c))) continue;
+    apply(k, el, el === me ? 1 : el === inMe ? 0.6 : 0.1, '三会');
+  }
+  for (const [k, el] of Object.entries(SANHE)) {
+    if (![...k].every((c) => set.has(c))) continue;
+    apply(k, el, el === me ? 1 : el === inMe ? 0.6 : 0.2, '三合');
+  }
+  for (let i = 0; i < branches.length; i++) {
+    for (let j = i + 1; j < branches.length; j++) {
+      const a = branches[i];
+      const b = branches[j];
+      const el = BRANCH_HE[a + b] || BRANCH_HE[b + a];
+      if (!el) continue;
+      if (inJu.has(a) && inJu.has(b)) continue;
+      const f = el === me ? 1 : el === inMe ? 0.8 : 0.5;
+      const hit = [];
+      for (const x of [a, b]) {
+        if (inJu.has(x)) continue;
+        if ((factor[x] ?? 1) > f) { factor[x] = f; hit.push(x); }
+      }
+      if (hit.length && f < 1) notes.push(`${a}${b}合${el}，${hit.join('')}根气按${Math.round(f * 10)}成计`);
+    }
+  }
+  return { factor, notes, inJu };
+}
+
+// 天干生扶是否真有根：折根后同类藏干累计 ≥0.3 才算有根（余气 0.3 折半后不足，作虚透）。
+const ROOT_EFFECTIVE_MIN = 0.3;
+function rootedWeightOf(pillars, el, factor) {
+  let w = 0;
+  for (const k of ['year', 'month', 'day', 'hour']) {
+    const pl = pillars[k];
+    const f = factor[pl.branch] ?? 1;
+    if (f <= 0.1) continue;
+    pl.hidden.forEach((h, i) => {
+      if (STEM_ELEMENT[h.stem] === el) w += (ROOT_HIDDEN_WEIGHT[i] ?? 0.1) * f;
+    });
+  }
+  return w;
+}
+
+/** 干支关系：五合、相冲、相克；六合、三合半合、三会半会拱会、冲、害、破、刑 */
+function buildRelations(pillars, keys = ['year', 'month', 'day', 'hour']) {
+  const stems = keys.map((k) => pillars[k].stem);
+  const branches = keys.map((k) => pillars[k].branch);
+
+  const stemOut = [];
+  for (let i = 0; i < stems.length; i++) {
+    for (let j = i + 1; j < stems.length; j++) {
+      const a = stems[i];
+      const b = stems[j];
+      if (a === b) continue;
+      const he = STEM_HE[a + b] || STEM_HE[b + a];
+      // 五合只是「有合」；是否真化要看月令、化神与争合妒合，不在这一层断言
+      if (he) { stemOut.push({ text: `${a}${b}合（化${he}待定）`, rank: 0 }); continue; }
+      if (hasPair(STEM_CHONG_PAIRS, a, b)) { stemOut.push({ text: `${a}${b}相冲`, rank: 1 }); continue; }
+      const ea = STEM_ELEMENT[a];
+      const eb = STEM_ELEMENT[b];
+      if (OVERCOMES[ea] === eb) stemOut.push({ text: `${a}克${b}`, rank: 3 });
+      else if (OVERCOMES[eb] === ea) stemOut.push({ text: `${b}克${a}`, rank: 3 });
+    }
+  }
+
+  const branchOut = [];
+  const set = new Set(branches);
+  const fullSans = [];
+  for (const [k, v] of Object.entries(SANHE)) {
+    if ([...k].every((c) => set.has(c))) {
+      branchOut.push({ text: `${k}三合${v}`, rank: 0 });
+      fullSans.push(k);
+    }
+  }
+  const fullHuis = [];
+  for (const [k, v] of Object.entries(SANHUI)) {
+    if ([...k].every((c) => set.has(c))) {
+      branchOut.push({ text: `${k}三会${v}`, rank: 0 });
+      fullHuis.push(k);
+    }
+  }
+  for (let i = 0; i < branches.length; i++) {
+    for (let j = i + 1; j < branches.length; j++) {
+      const a = branches[i];
+      const b = branches[j];
+      if (a === b) {
+        // 同支不是"没关系"：辰午酉亥两柱同见为自刑
+        if (XING_SELF.includes(a)) branchOut.push({ text: `${a}${b}自刑`, rank: 2 });
+        continue;
+      }
+      const he = BRANCH_HE[a + b] || BRANCH_HE[b + a];
+      const sh = Object.keys(SANHE).find((k) => k.includes(a) && k.includes(b));
+      const hui = Object.keys(SANHUI).find((k) => k.includes(a) && k.includes(b));
+      if (he) {
+        // 六合优先，不再重复标半合/半会
+        branchOut.push({ text: `${a}${b}合${he}`, rank: 0 });
+      } else {
+        if (sh && !fullSans.includes(sh)) {
+          const mid = sh[1];
+          const kind = a === mid || b === mid ? '半合' : '拱合';
+          branchOut.push({ text: `${a}${b}${kind}${SANHE[sh]}`, rank: 0 });
+        }
+        if (hui && !fullHuis.includes(hui)) {
+          const adj = Math.abs(hui.indexOf(a) - hui.indexOf(b)) === 1;
+          branchOut.push({ text: `${a}${b}${adj ? '半会' : '拱会'}${SANHUI[hui]}`, rank: 0 });
+        }
+      }
+      if (hasPair(BRANCH_CHONG, a, b)) branchOut.push({ text: `${a}${b}相冲`, rank: 1 });
+      if (hasPair(BRANCH_HAI, a, b)) branchOut.push({ text: `${a}${b}相害`, rank: 2 });
+      if (hasPair(BRANCH_PO, a, b)) branchOut.push({ text: `${a}${b}相破`, rank: 2 });
+      for (const g of XING_GROUPS) {
+        if (g.includes(a) && g.includes(b)) branchOut.push({ text: `${a}${b}相刑`, rank: 2 });
+      }
+    }
+  }
+
+  const uniq = (arr) => {
+    const seen = new Set();
+    const out = [];
+    for (const x of [...arr].sort((p, q) => p.rank - q.rank)) {
+      if (!seen.has(x.text)) { seen.add(x.text); out.push(x.text); }
+    }
+    return out;
+  };
+  return { stems: uniq(stemOut), branches: uniq(branchOut) };
+}
+
+/** 十神：以日干为我 */
+function tenGod(dayStem, otherStem) {
+  const me = STEM_ELEMENT[dayStem];
+  const it = STEM_ELEMENT[otherStem];
+  const samePolarity = isYangStem(dayStem) === isYangStem(otherStem);
+  if (me === it) return samePolarity ? '比肩' : '劫财';
+  if (GENERATES[me] === it) return samePolarity ? '食神' : '伤官';
+  if (OVERCOMES[me] === it) return samePolarity ? '偏财' : '正财';
+  if (OVERCOMES[it] === me) return samePolarity ? '七杀' : '正官';
+  if (GENERATES[it] === me) return samePolarity ? '偏印' : '正印';
+  return '?';
+}
+
+function nayin(ganzhiIdx) {
+  return nayinOf(ganzhiIdx).name;
+}
+
+const JIE_TO_MONTH_BRANCH = { 0: 1, 2: 2, 4: 3, 6: 4, 8: 5, 10: 6, 12: 7, 14: 8, 16: 9, 18: 10, 20: 11, 22: 0 };
+
+function pillar(ganzhiIdx, dayStem) {
+  const g = ganzhiName(ganzhiIdx);
+  const hidden = HIDDEN_STEMS[g.branch];
+  return {
+    ganzhi: g.name,
+    stem: g.stem,
+    branch: g.branch,
+    stemElement: STEM_ELEMENT[g.stem],
+    branchElement: BRANCH_ELEMENT[g.branch],
+    stemTenGod: dayStem ? tenGod(dayStem, g.stem) : null,
+    hidden: hidden.map((s, i) => ({
+      stem: s,
+      element: STEM_ELEMENT[s],
+      tenGod: dayStem ? tenGod(dayStem, s) : null,
+      role: ['本气', '中气', '余气'][i] ?? '余气',
+    })),
+    nayin: nayin(ganzhiIdx),
+  };
+}
+
+/**
+ * 真太阳时修正
+ * @returns {{offsetMinutes:number, jd:number, note:string}}
+ */
+function applyTrueSolar(jd, longitude) {
+  const p = jdToParts(jd);
+  if (longitude == null || Number.isNaN(longitude)) {
+    return { offsetMinutes: 0, jd, note: '未提供经度，按东八区平太阳时' };
+  }
+  const longitudeMinutes = (longitude - 120) * 4;
+  const eot = equationOfTime(p.year, p.month, p.day);
+  const offset = longitudeMinutes + eot;
+  return {
+    offsetMinutes: Math.round(offset * 10) / 10,
+    jd: jd + offset / 1440,
+    note: `经度差 ${longitudeMinutes.toFixed(1)} 分 + 均时差 ${eot.toFixed(1)} 分`,
+  };
+}
+
+/**
+ * 人元司权：生在本月第几日、哪一藏干当权。
+ * 日数按「节令日」与出生日的日差计，节当日为第 1 日；固定 30 日表，
+ * 第 31 日以后不再硬分摊，按本气算并标 beyond。
+ * @param {string} monthBranch 月支（寅…丑）
+ * @param {number} birthJdn 出生日的儒略日数（含真太阳时修正后的日）
+ * @param {number} termJd 本月「节」的儒略日
+ */
+function renyuanOf(monthBranch, birthJdn, termJd) {
+  const table = RENYUAN_TABLE[monthBranch];
+  if (!table) return null;
+  const segments = [];
+  let from = 1;
+  for (const [stem, days] of table) {
+    segments.push({ stem, element: STEM_ELEMENT[stem], from, to: from + days - 1 });
+    from += days;
+  }
+  const tableDays = from - 1;
+  const day = Math.max(1, Math.floor(birthJdn) - Math.floor(termJd + 0.5) + 1);
+  const beyond = day > tableDays;
+  const idx = beyond ? segments.length - 1 : segments.findIndex((s) => day >= s.from && day <= s.to);
+  const seg = segments[idx] || segments[segments.length - 1];
+  const next = segments[idx + 1] || null;
+  return {
+    month: monthBranch,
+    day,
+    tableDays,
+    segments,
+    active: seg.stem,
+    activeElement: seg.element,
+    segment: { from: seg.from, to: seg.to },
+    next: next ? { stem: next.stem, element: next.element, from: next.from, inDays: next.from - day } : null,
+    // 司权表与本柱藏干表口径不同：亥月的余气戊只出现在司权表里
+    inHidden: (HIDDEN_STEMS[monthBranch] || []).includes(seg.stem),
+    beyond,
+    note: '人元司权按「节」当日起算，节当日为第 1 日，日差用本盘所用时刻（含真太阳时）所在日计；本插件固定 30 日表（余气 → 中气 → 本气），第 31 日以后按本气算。只作解释层的一层细节，不改取格。',
+  };
+}
+
+/**
+ * 排四柱八字
+ * @param {object} input { year,month,day,hour,minute, gender:'male'|'female', longitude?, lateZi?:boolean, trueSolar?:boolean }
+ */
+function buildBazi(input) {
+  assertCivil(input);
+  let { year, month, day, hour = 0, minute = 0, gender = 'male' } = input;
+  // 时辰未知：内部仍按「正午」跑完整条管线（大运、旺衰都要有个基准才能算），
+  // 但对外一律不承认这个钟点——时柱置空、文本不出现具体时刻、精度降为按日。
+  const hourUnknown = input.hourUnknown === true;
+  if (hourUnknown) { hour = 12; minute = 0; }
+  const lateZi = input.lateZi !== false;
+  const useTrueSolar = input.trueSolar !== false;
+  // 1986–1991 中国夏令时：出生证钟面时间普遍是「拨快 1 小时」的钟面时间，
+  // 不校正会让时柱（乃至跨 23:00 的日柱）整档偏；显式传 dst:false 可关闭。
+  const dst = input.dst === false ? { applied: false, note: null } : applyDst({ year, month, day, hour, minute });
+  if (dst.applied) {
+    year = dst.year; month = dst.month; day = dst.day; hour = dst.hour; minute = dst.minute;
+  }
+
+  const civilJd = partsToJd({ year, month, day, hour, minute });
+  // 地址 -> 经度：手填的 longitude 优先，其次按地址查表
+  const geo = input.geo || (input.address ? resolveAddress(input.address) : null);
+  const longitude = typeof input.longitude === 'number'
+    ? input.longitude
+    : (geo && typeof geo.lon === 'number' ? geo.lon : undefined);
+  const solar = useTrueSolar ? applyTrueSolar(civilJd, longitude) : { offsetMinutes: 0, jd: civilJd, note: '未启用真太阳时' };
+  const jd = solar.jd;
+
+  // 八字只用「节」定月柱与起运（气不参与），传 jieOnly 省掉一半节气求值
+  const terms = termWindow(year, { jieOnly: true });
+  const prevJieTerm = previousJie(terms, jd);
+  const nextJieTerm = nextJie(terms, jd);
+
+  // 年柱：以立春为界
+  const lichun = terms.find((t) => t.index === 2 && t.year === year);
+  const solarYear = lichun && jd < lichun.jd ? year - 1 : year;
+  const yearIdx = (((solarYear - 4) % 60) + 60) % 60;
+  const yearStem = STEMS[yearIdx % 10];
+
+  // 月柱：以「节」为界
+  const monthBranchIdx = JIE_TO_MONTH_BRANCH[prevJieTerm.index];
+  const yinMonthStem = ((STEMS.indexOf(yearStem) % 5) * 2 + 2) % 10;
+  const monthOffset = ((monthBranchIdx - 2) % 12 + 12) % 12; // 0 = 寅月
+  const monthStemIdx = (yinMonthStem + monthOffset) % 10;
+  const monthIdx = sexagenaryIndex(monthStemIdx, monthBranchIdx);
+
+  // 日柱：23:00 后是否换日
+  const jdnBase = Math.floor(jd + 0.5);
+  const hourOfDay = jdToParts(jd).hour;
+  const jdn = lateZi && hourOfDay >= 23 ? jdnBase + 1 : jdnBase;
+  const dayIdx = dayGanzhiIndex(jdn);
+  const dayStem = STEMS[dayIdx % 10];
+
+  // 时柱：五鼠遁
+  const hourBranchIdx = Math.floor(((hourOfDay + 1) % 24) / 2);
+  const ziHourStem = ((STEMS.indexOf(dayStem) % 5) * 2) % 10;
+  const hourStemIdx = (ziHourStem + hourBranchIdx) % 10;
+  const hourIdx = sexagenaryIndex(hourStemIdx, hourBranchIdx);
+
+  const pillars = {
+    year: pillar(yearIdx, dayStem),
+    month: pillar(monthIdx, dayStem),
+    day: pillar(dayIdx, dayStem),
+    hour: pillar(hourIdx, dayStem),
+  };
+
+  // 大运
+  const isYangYear = STEMS.indexOf(yearStem) % 2 === 0;
+  const forward = (isYangYear && gender === 'male') || (!isYangYear && gender === 'female');
+  const spanDays = forward ? nextJieTerm.jd - jd : jd - prevJieTerm.jd;
+  const totalMonths = spanDays * 4; // 3 天 = 1 年 = 12 个月
+  let startAgeYears = Math.floor(totalMonths / 12);
+  let startAgeMonths = Math.round(totalMonths % 12);
+  // 四舍五入到 12 个月时必须进位，否则显示「X 岁 12 个月起运」
+  if (startAgeMonths >= 12) { startAgeMonths -= 12; startAgeYears += 1; }
+
+  // 交运：三日折一年。
+  // 古法三条换算是同一比例的三种说法——3 日折 1 年、1 日折 4 个月、1 时辰折 10 日：
+  // 把「出生 → 起运那一侧的节令」的真实间隔按 365.2422/3（≈121.7474）倍放大，
+  // 就是起运那一刻；放大后的 1/12 恰好 121.7474/12 ≈ 10.15 天，即「一时辰十日」。
+  // 一年取回归年 365.2422 日（交运日细算各家不一，这里固定这一个口径并写明）。
+  const JIAO_YEAR_DAYS = 365.2422;
+  const JIAO_SCALE = JIAO_YEAR_DAYS / 3;
+  const jiaoFromTerm = forward ? nextJieTerm : prevJieTerm;
+  const jiaoJd = jd + spanDays * JIAO_SCALE;
+  const jiaoParts = jdToParts(jiaoJd);
+  // 每步大运在「同月同日同时刻」换；公历闰日（2 月 29 日生）退到 2 月 28 日
+  const addYearsClamped = (p, n) => {
+    const y = p.year + n;
+    return { year: y, month: p.month, day: Math.min(p.day, daysInMonth(y, p.month)), hour: p.hour, minute: p.minute };
+  };
+
+  const dayun = [];
+  const dayunWindows = [];
+  for (let i = 1; i <= 8; i++) {
+    const idx = (((monthIdx + (forward ? i : -i)) % 60) + 60) % 60;
+    const g = ganzhiName(idx);
+    const fromJd = partsToJd(addYearsClamped(jiaoParts, (i - 1) * 10));
+    const toJd = partsToJd(addYearsClamped(jiaoParts, i * 10));
+    dayun.push({
+      step: i,
+      startAge: startAgeYears + (i - 1) * 10,
+      ganzhi: g.name,
+      stem: g.stem,
+      branch: g.branch,
+      stemTenGod: tenGod(dayStem, g.stem),
+      nayin: nayin(idx),
+      // 这一步大运的起止交运时刻（与摘要/面板同源，可直接拿来对年表）
+      fromDate: formatJd(fromJd),
+      toDate: formatJd(toJd),
+    });
+    dayunWindows.push({ step: i, ganzhi: g.name, fromJd, toJd });
+  }
+
+  // 流年（默认从「今年」起排 10 年；传 input.nowYear 可钉死基准年，用于复现历史结论）
+  const thisYear = Number(input.nowYear) || new Date().getFullYear();
+  const liunian = [];
+  for (let y = thisYear; y < thisYear + 10; y++) {
+    const idx = (((y - 4) % 60) + 60) % 60;
+    liunian.push({
+      year: y,
+      age: y - solarYear + 1,
+      ganzhi: ganzhiName(idx).name,
+      stemTenGod: tenGod(dayStem, ganzhiName(idx).stem),
+    });
+  }
+
+  // 五行统计（天干 1.0；地支藏干按 WUXING_HIDDEN_WEIGHT）
+  const wuxing = { 木: 0, 火: 0, 土: 0, 金: 0, 水: 0 };
+  for (const p of Object.values(pillars)) {
+    wuxing[p.stemElement] += 1;
+    p.hidden.forEach((h, i) => {
+      wuxing[h.element] += WUXING_HIDDEN_WEIGHT[i] ?? 0.1;
+    });
+  }
+  for (const k of Object.keys(wuxing)) wuxing[k] = Math.round(wuxing[k] * 10) / 10;
+
+  // 旬空（以日柱所在旬）
+  const xunStart = Math.floor(dayIdx / 10) * 10;
+  const kongwang = [
+    BRANCHES[(xunStart + 10) % 12],
+    BRANCHES[(xunStart + 11) % 12],
+  ];
+
+  // ── 十二长生、各柱空亡、神煞 ──────────────────────────────
+  const CHANGSHENG = ['长生', '沐浴', '冠带', '临官', '帝旺', '衰', '病', '死', '墓', '绝', '胎', '养'];
+  const CS_START = { 甲: 11, 乙: 6, 丙: 2, 丁: 9, 戊: 2, 己: 9, 庚: 5, 辛: 0, 壬: 8, 癸: 3 };
+  const isYang = (s) => STEMS.indexOf(s) % 2 === 0;
+
+  function changsheng(stem, branch) {
+    const start = CS_START[stem];
+    const bi = BRANCHES.indexOf(branch);
+    const step = isYang(stem) ? bi - start : start - bi;
+    return CHANGSHENG[((step % 12) + 12) % 12];
+  }
+
+  // 旬空统一走 calendar.xunKongOf：此前 bazi / liuyao / daliuren 各写一份公式，
+  // 三份形式不同（一处用 (start+10)%12、一处用 (10-2k)%12、一处查表），改一处极易漏改另两处。
+  const monthBranch = pillars.month.branch;
+
+  // 神煞：表驱动、双查法（年干/日干、年支/日支、月支、日柱、时柱），详见 engine/shensha.js
+  const shensha = computeBaziShensha(pillars, kongwang);
+
+  for (const key of ['year', 'month', 'day', 'hour']) {
+    const pl = pillars[key];
+    pl.dishi = changsheng(dayStem, pl.branch);
+    pl.zizuo = changsheng(pl.stem, pl.branch);
+    pl.kongwang = xunKongOf(pl.ganzhi);
+    // shensha 保持字符串数组以兼容既有 UI / 测试；明细见 shenshaDetail
+    pl.shensha = shensha.detail[key].map((x) => x.name);
+    pl.shenshaDetail = shensha.detail[key];
+  }
+
+  // ── 日主旺衰（月令 + 通根 + 天干帮扶，量化但规则透明）──
+  const SEASON_EL = { 寅: '木', 卯: '木', 巳: '火', 午: '火', 申: '金', 酉: '金', 亥: '水', 子: '水', 辰: '土', 戌: '土', 丑: '土', 未: '土' };
+  const me = STEM_ELEMENT[dayStem];
+  const seasonEl = SEASON_EL[monthBranch];
+  let monthW;
+  let monthWord;
+  if (me === seasonEl) { monthW = 3; monthWord = '旺'; }
+  else if (GENERATES[seasonEl] === me) { monthW = 2; monthWord = '相'; }
+  else if (GENERATES[me] === seasonEl) { monthW = 1; monthWord = '休'; }
+  else if (OVERCOMES[me] === seasonEl) { monthW = 0.5; monthWord = '囚'; }
+  else { monthW = 0; monthWord = '死'; }
+
+  const factorInfo = branchRootFactors(pillars, me);
+  let rootScore = 0;
+  const rootBranches = [];
+  for (const key of ['year', 'month', 'day', 'hour']) {
+    const pl = pillars[key];
+    const f = factorInfo.factor[pl.branch] ?? 1;
+    let hit = false;
+    pl.hidden.forEach((h, i) => {
+      if (STEM_ELEMENT[h.stem] === me) { rootScore += (ROOT_HIDDEN_WEIGHT[i] ?? 0.1) * f; hit = true; }
+      else if (GENERATES[STEM_ELEMENT[h.stem]] === me) { rootScore += (ROOT_HIDDEN_WEIGHT[i] ?? 0.1) * 0.4 * f; hit = true; }
+    });
+    if (hit) rootBranches.push(pl.branch);
+  }
+
+  let helpScore = 0;
+  const helpers = [];
+  const drainers = [];
+  const virtualHelpers = [];
+  for (const key of ['year', 'month', 'hour']) {
+    const st = pillars[key].stem;
+    const el2 = STEM_ELEMENT[st];
+    if (el2 === me || GENERATES[el2] === me) {
+      // 天干有根才出得上力；虚透（折根后不足 0.3）只按半力计
+      const base = el2 === me ? 1 : 0.8;
+      if (rootedWeightOf(pillars, el2, factorInfo.factor) >= ROOT_EFFECTIVE_MIN) helpScore += base;
+      else { helpScore += base * 0.5; virtualHelpers.push(st); }
+      helpers.push(st);
+    } else if (OVERCOMES[el2] === me) { helpScore -= 1; drainers.push(st); }
+    else if (OVERCOMES[me] === el2) { helpScore -= 0.8; drainers.push(st); }
+    else { helpScore -= 0.5; drainers.push(st); }
+  }
+
+  const total = Math.round((monthW + rootScore + helpScore) * 10) / 10;
+  const level = total >= 4 ? '身强' : total >= 2.5 ? '偏强' : total >= 1.5 ? '中和' : total >= 0.5 ? '偏弱' : '身弱';
+  const structureText = factorInfo.notes.length ? `；合会折根：${factorInfo.notes.join('、')}` : '';
+  const virtualText = virtualHelpers.length ? `；虚透${virtualHelpers.join('')}帮扶减半` : '';
+  const strength = {
+    level,
+    score: total,
+    detail: `月令${monthBranch}${seasonEl}，日主${me}${monthWord}(${monthW})；通根${rootBranches.join('') || '无'}(${rootScore.toFixed(1)})；天干帮扶${helpers.join('') || '无'}／耗泄${drainers.join('') || '无'}(${helpScore.toFixed(1)})${structureText}${virtualText}`,
+    method: '月令权重 3/2/1/0.5/0 + 地支藏干通根（三会/三合/六合折根）+ 天干帮扶（虚透减半），量化后分档；属简化算法，非唯一流派',
+    parts: {
+      season: { branch: monthBranch, element: seasonEl, word: monthWord, weight: monthW },
+      roots: rootBranches,
+      rootScore: Math.round(rootScore * 10) / 10,
+      helpers,
+      drainers,
+      helpScore: Math.round(helpScore * 10) / 10,
+      structure: factorInfo.notes,
+      virtualHelpers,
+    },
+  };
+
+  // ── 格局 / 用神 / 行运 ─────────────────────────────────────
+  const frame = analyzeBaziFrame({ pillars, dayStem, monthBranch, strength, wuxing });
+
+  // ── 大运/流年与原局的地支关系 ──
+  const pairRel = (a, b) => {
+    if (!a || !b) return [];
+    // 大运/流年支与原局同支：辰午酉亥为自刑，其余同支不算关系
+    if (a === b) return XING_SELF.includes(a) ? ['自刑'] : [];
+    const out = [];
+    if (BRANCH_HE[a + b] || BRANCH_HE[b + a]) out.push('合');
+    if (hasPair(BRANCH_CHONG, a, b)) out.push('冲');
+    if (hasPair(BRANCH_HAI, a, b)) out.push('害');
+    if (hasPair(BRANCH_PO, a, b)) out.push('破');
+    for (const g of XING_GROUPS) if (g.includes(a) && g.includes(b)) out.push('刑');
+    return out;
+  };
+  const natalBranches = ['year', 'month', 'day', 'hour'].map((k) => pillars[k].branch);
+  const relOf = (branch) => {
+    const seen = new Set();
+    const out = [];
+    for (const b of natalBranches) {
+      for (const r of pairRel(b, branch)) {
+        const t = r + b;
+        if (!seen.has(t)) { seen.add(t); out.push(t); }
+      }
+    }
+    return out;
+  };
+  for (const d of dayun) {
+    d.relations = relOf(d.branch);
+    d.luck = scoreLuck(d.ganzhi, frame);
+  }
+  for (const l of liunian) {
+    l.relations = relOf(l.ganzhi[1]);
+    l.luck = scoreLuck(l.ganzhi, frame);
+  }
+
+  // ── 岁运并临 / 伏吟反吟：只标干支层面的「变动信号」，不判吉凶 ──
+  // 流年按立春起算（该年立春到次年立春），当值大运取与这一区间相交的步；
+  // 交运落在这一年里时，前后两步都在本年当过值，两条都列出。
+  const NATAL_LABEL = { year: '年柱', month: '月柱', day: '日柱', hour: '时柱' };
+  const stemOvercomes = (a, b) => OVERCOMES[STEM_ELEMENT[a]] === STEM_ELEMENT[b];
+  const tianKeDiChong = (a, b) => {
+    if (typeof a !== 'string' || typeof b !== 'string' || a.length < 2 || b.length < 2) return false;
+    if (!(a[0] in STEM_ELEMENT) || !(b[0] in STEM_ELEMENT)) return false;
+    return (stemOvercomes(a[0], b[0]) || stemOvercomes(b[0], a[0])) && hasPair(BRANCH_CHONG, a[1], b[1]);
+  };
+  const lichunJd = (y) => {
+    const t = termWindow(y, { jieOnly: true }).find((x) => x.index === 2 && jdToParts(x.jd).year === y);
+    return t ? t.jd : partsToJd({ year: y, month: 2, day: 4 });
+  };
+  for (const l of liunian) {
+    const yStart = lichunJd(l.year);
+    const yEnd = lichunJd(l.year + 1);
+    const active = dayunWindows.filter((w) => w.fromJd < yEnd && w.toJd > yStart);
+    const signals = [];
+    for (const w of active) {
+      if (w.ganzhi === l.ganzhi) {
+        signals.push({ type: '岁运并临', target: `第${w.step}步大运`, detail: `大运与流年同为${l.ganzhi}` });
+      } else if (tianKeDiChong(w.ganzhi, l.ganzhi)) {
+        signals.push({ type: '运年反吟', target: `第${w.step}步大运`, detail: `大运${w.ganzhi}与流年${l.ganzhi}天克地冲` });
+      }
+      // 大运与本命四柱的伏吟/反吟：整步大运都在，逐年列出，不按流年另算一次
+      for (const key of ['year', 'month', 'day', 'hour']) {
+        const g = pillars[key].ganzhi;
+        if (!g) continue;
+        if (w.ganzhi === g) {
+          signals.push({ type: '大运伏吟', target: `第${w.step}步大运·${NATAL_LABEL[key]}`, detail: `大运${w.ganzhi}与${NATAL_LABEL[key]}同干支` });
+        } else if (tianKeDiChong(w.ganzhi, g)) {
+          signals.push({ type: '大运反吟', target: `第${w.step}步大运·${NATAL_LABEL[key]}`, detail: `大运${w.ganzhi}与${NATAL_LABEL[key]}${g}天克地冲` });
+        }
+      }
+    }
+    for (const key of ['year', 'month', 'day', 'hour']) {
+      const g = pillars[key].ganzhi;
+      if (!g) continue;
+      if (l.ganzhi === g) {
+        signals.push({ type: '流年伏吟', target: NATAL_LABEL[key], detail: `流年${l.ganzhi}与${NATAL_LABEL[key]}同干支` });
+      } else if (tianKeDiChong(l.ganzhi, g)) {
+        signals.push({ type: '流年反吟', target: NATAL_LABEL[key], detail: `流年${l.ganzhi}与${NATAL_LABEL[key]}${g}天克地冲` });
+      }
+    }
+    l.suiyun = {
+      dayun: active.map((w) => ({ step: w.step, ganzhi: w.ganzhi })),
+      signals,
+      note: '只标干支重复与天克地冲这类变动信号，不判吉凶；大运按该年立春到次年立春的区间取，交运落在年内时前后两步并列；大运与本命四柱的伏吟/反吟整步大运都在，逐年重复列出',
+    };
+  }
+
+  const p = jdToParts(jd);
+
+  // ── 胎元 / 胎息 / 命宫 / 身宫 ──
+  // 胎元：月柱天干进一位、地支进三位（受胎之月的干支）
+  const mStemIdx = STEMS.indexOf(pillars.month.stem);
+  const mBranchIdx = BRANCHES.indexOf(pillars.month.branch);
+  const taiyuan = ganzhiName(sexagenaryIndex((mStemIdx + 1) % 10, (mBranchIdx + 3) % 12));
+  // 胎息：日柱天干五合、地支六合（六合两支序数之和恒为 1 mod 12）
+  const dayStemIdx = STEMS.indexOf(pillars.day.stem);
+  const dayBranchIdx = BRANCHES.indexOf(pillars.day.branch);
+  const taixi = ganzhiName(sexagenaryIndex((dayStemIdx + 5) % 10, (1 - dayBranchIdx + 12) % 12));
+  // 命宫 / 身宫：以生月、生时两支的合数定宫（Tyme 口径）。
+  // 命宫：27 − 月支 − 时支，取模后 +2；身宫：11 + 月支 + 时支，取模后 +2。
+  // 两支合数落 0–11 后并入六十甲子，天干随年干自然对齐，无需另推五虎遁。
+  const hourBrIdxForGong = BRANCHES.indexOf(pillars.hour.branch);
+  const yearStemIdxForGong = STEMS.indexOf(pillars.year.stem);
+  const mingIdx = (((yearStemIdxForGong * 12 + ((27 - mBranchIdx - hourBrIdxForGong) % 12) + 2) % 60) + 60) % 60;
+  const bodyIdx = (((yearStemIdxForGong * 12 + ((11 + mBranchIdx + hourBrIdxForGong) % 12) + 2) % 60) + 60) % 60;
+  const minggong = ganzhiName(mingIdx);
+  const shengong = ganzhiName(bodyIdx);
+
+  // 人元司权：按节令到出生日的日差定当权藏干（节当日为第 1 日）
+  const renyuan = renyuanOf(BRANCHES[monthBranchIdx], jdnBase, prevJieTerm.jd);
+  if (renyuan) renyuan.term = { name: prevJieTerm.name, time: formatJd(prevJieTerm.jd) };
+
+  const out = {
+    system: 'bazi',
+    // 时柱未知时不参与干支关系（否则「时干合日干」这类结论就建立在编造的钟点上）
+    relations: buildRelations(pillars, hourUnknown ? ['year', 'month', 'day'] : undefined),
+    palaces: {
+      taiyuan: { ganzhi: taiyuan.name, note: '月干进一、月支进三' },
+      taixi: { ganzhi: taixi.name, note: '日干五合、日支六合' },
+      minggong: { ganzhi: minggong.name, branch: minggong.branch, note: '生月与生时支合数定宫（27 减，取模后 +2）；干随六十甲子' },
+      shengong: { ganzhi: shengong.name, branch: shengong.branch, note: '生月与生时支合数定宫（11 加，取模后 +2）；干随六十甲子' },
+    },
+    input: {
+      civil: { year, month, day, hour, minute },
+      gender,
+      longitude: longitude ?? null,
+      address: input.address || null,
+      geo,
+      lateZi,
+      trueSolar: useTrueSolar,
+      dst: { applied: !!dst.applied, note: dst.note || null },
+    },
+    solarTime: {
+      civilText: `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')} ${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`,
+      trueSolarText: formatJd(jd),
+      offsetMinutes: solar.offsetMinutes,
+      note: dst.applied ? `${dst.note}；${solar.note}` : solar.note,
+      lunarYearForPillar: solarYear,
+    },
+    jieqi: {
+      previous: { name: prevJieTerm.name, time: formatJd(prevJieTerm.jd) },
+      next: { name: nextJieTerm.name, time: formatJd(nextJieTerm.jd) },
+      // 距「节」的分钟数（取两侧较小值）。是否提示复核由摘要层决定，阈值 20 分钟：
+      // 与 NAOJ 历要项对拍实测节气最多偏 13.5 分钟，20 分钟留出余量。
+      nearBoundaryMinutes: Math.round(Math.min(jd - prevJieTerm.jd, nextJieTerm.jd - jd) * 1440),
+    },
+    renyuan,
+    pillars,
+    dayMaster: { stem: dayStem, element: STEM_ELEMENT[dayStem], yinYang: isYangStem(dayStem) ? '阳' : '阴' },
+    wuxing,
+    kongwang,
+    shensha,
+    dayun: {
+      direction: forward ? '顺行' : '逆行',
+      rule: `${isYangYear ? '阳' : '阴'}年${gender === 'male' ? '男' : '女'}${forward ? '顺排' : '逆排'}`,
+      startAge: { years: startAgeYears, months: startAgeMonths },
+      toNextJieDays: Math.round(spanDays * 100) / 100,
+      // 交运时刻（日/时辰级）：上方 startAge 是四舍五入到月的旧字段，两者同源、不互相覆盖
+      jiao: {
+        at: formatJd(jiaoJd),
+        jd: Math.round(jiaoJd * 1e6) / 1e6,
+        scaleDaysPerDay: JIAO_SCALE,
+        yearDays: JIAO_YEAR_DAYS,
+        spanDays: Math.round(spanDays * 1e4) / 1e4,
+        from: { name: jiaoFromTerm.name, time: formatJd(jiaoFromTerm.jd) },
+        frame: solar.offsetMinutes ? '真太阳时' : '平太阳时',
+        offsetMinutes: solar.offsetMinutes,
+        note: '三日折一年：出生到节令的真实间隔按 365.2422/3 放大后加到出生时刻；同一比例即「一日折四月、一时辰折十日」，每步大运在同月同日同时刻换',
+      },
+      list: dayun,
+    },
+    strength,
+    frame,
+    climate: frame.yongshen.climate || frame.yongshen.tiaohou || null,
+    liunian,
+    liunianFrom: thisYear,
+  };
+
+  // ── 时辰未知：把「不该被当成已知」的东西全部收回 ──────────
+  // 内部按正午跑完整条管线，是为了让大运/旺衰有个基准；但对外必须守住三件事：
+  // 时柱不给、具体钟点不给、精度不冒充。任何一处漏了，用户就会把它当成算准的盘。
+  if (hourUnknown) {
+    const hourPillar = out.pillars.hour;
+    out.hourUnknown = true;
+    // 内部语义标记，不是钟点；正文里只说「正午」
+    out.provisionalHour = 'noon';
+    // 时柱整体不排：键保留为 null（不删键），下游 for...in 不会崩，但读不到值
+    out.pillars.hour = null;
+    // 命宫 / 身宫由「生月 + 生时支」定，时支没了就不能给
+    out.palaces.minggong = null;
+    out.palaces.shengong = null;
+    // 输入回显也不留钟点：否则等于把占位值还给了用户
+    out.input.civil.hour = null;
+    out.input.civil.minute = null;
+    const dateOnly = `${out.input.civil.year}-${String(out.input.civil.month).padStart(2, '0')}-${String(out.input.civil.day).padStart(2, '0')}`;
+    out.solarTime.civilText = `${dateOnly}（时辰未知）`;
+    out.solarTime.trueSolarText = `${dateOnly}（时辰未知）`;
+    // 大运：起运与交运都是「出生时刻 + 放大间隔」推出来的，没有出生时刻就只能到日
+    out.dayun.precision = 'day';
+    out.dayun.jiao = null;
+    out.dayun.note = '时柱暂缺：起运与交运按日估算，仅供参考';
+    out.dayun.list = out.dayun.list.map((d) => ({
+      ...d,
+      fromDate: d.fromDate ? String(d.fromDate).slice(0, 10) : d.fromDate,
+      toDate: d.toDate ? String(d.toDate).slice(0, 10) : d.toDate,
+    }));
+    // 五行不含时柱重算：否则等于把一个编出来的钟点算进了旺衰
+    if (hourPillar) {
+      const w = { ...out.wuxing };
+      w[hourPillar.stemElement] -= 1;
+      hourPillar.hidden.forEach((h, i) => { w[h.element] -= (WUXING_HIDDEN_WEIGHT[i] ?? 0.1); });
+      for (const k of Object.keys(w)) w[k] = Math.round(Math.max(0, w[k]) * 10) / 10;
+      out.wuxing = w;
+    }
+    // 神煞：时柱那一列清空；只落在时柱上的条目整条去掉（不能留个空壳说「时柱有X」）
+    if (out.shensha && out.shensha.detail) {
+      out.shensha.detail.hour = [];
+      if (Array.isArray(out.shensha.groups)) {
+        out.shensha.groups = out.shensha.groups
+          .map((g) => ({ ...g, items: (g.items || []).filter((i) => (i.pillars || []).some((k) => k !== 'hour')) }))
+          .filter((g) => g.items.length);
+        out.shensha.count = out.shensha.groups.reduce((n, g) => n + g.items.length, 0);
+      }
+    }
+    // 旺衰与格局：算法没变，但基准是正午——标出来，别让人以为是定时辰算的
+    out.strength.precision = 'three-pillars';
+    out.notes = [
+      '时柱暂缺：未提供出生时刻，时柱不参与任何判定',
+      '旺衰、格局、用神按年/月/日三柱估算，补上时柱后可能改变',
+    ];
+  }
+  return out;
+}
 
 return { HIDDEN_STEMS, RENYUAN_TABLE, STEM_ELEMENT, BRANCH_ELEMENT, buildRelations, tenGod, nayin, applyTrueSolar, renyuanOf, buildBazi };
 })();
@@ -9519,6 +9587,9 @@ function buildTrend(input) {
       dayMaster: `${dayStem}（${r.dayMaster.yinYang}${r.dayMaster.element}）`,
       strength: { level: r.strength.level, score: r.strength.score, boundary },
       toAge,
+      // 当前年份由调用方给（asOf）：引擎不读挂钟，同一条线在任意时刻复算都一致。
+      // 没给就不写这个键，summary 那边据此省掉「你现在在第几步」。
+      ...(Number.isInteger(input.nowYear) ? { nowYear: input.nowYear } : {}),
       ...(boundary
         ? {
           boundaryNote:
@@ -15123,6 +15194,11 @@ const SYSTEM_LIMITS = {
     },
   ],
   bazi: [
+    {
+      id: 'bazi-hour-unknown',
+      title: '时辰未知时，只给三柱，不给紫微与合盘',
+      text: '不知道出生时辰时，本插件不排时柱，起运按日估算，并把「时柱按正午暂算」写在结果第一行。紫微（命宫由生月与生时支定）与合盘（夫妻宫、大运都依赖时支）一律不出盘——不是保守，是这两套离了时支就不成立，硬排出来只是看着像盘。',
+    },
     {
       id: 'bazi-no-event',
       title: '不预测具体年份的事件',
@@ -16823,7 +16899,10 @@ function baziInterpret(r) {
       key: 'palaces', label: '胎命身',
       text: `胎元 ${r.palaces.taiyuan.ganzhi}（月干进一、月支进三）；`
         + `${r.palaces.taixi ? `胎息 ${r.palaces.taixi.ganzhi}（日干五合、日支六合）；` : ''}`
-        + `命宫 ${r.palaces.minggong.ganzhi}、身宫 ${r.palaces.shengong.ganzhi}（生月与生时两支合数定宫，天干随六十甲子）。`
+        + (r.palaces.minggong && r.palaces.shengong
+          ? `命宫 ${r.palaces.minggong.ganzhi}、身宫 ${r.palaces.shengong.ganzhi}（生月与生时两支合数定宫，天干随六十甲子）。`
+          // 时辰未知：这两宫由生时支定，没有时支就没有宫位——宁可空着，不能拿正午顶上
+          : '命宫与身宫由生月与生时支合数定宫：时柱暂缺，这两宫不排。')
         + '四宫是读盘的辅助坐标，不单独折吉凶。',
     }] : []),
     {
@@ -18849,7 +18928,8 @@ function rectifyBirth(opts) {
       hour,
       label: `${String(hour).padStart(2, '0')}:00 起`,
       dayGanzhi: chart.pillars.day.ganzhi,
-      hourGanzhi: chart.pillars.hour.ganzhi,
+      // 时辰未知时没有时柱可校正：给 null，让调用方自己判断要不要做这件事
+      hourGanzhi: chart.pillars.hour ? chart.pillars.hour.ganzhi : null,
       score: clean.length ? matched.length / clean.length : 0,
       hits: matched.length,
       total: clean.length,
@@ -20513,6 +20593,615 @@ function buildEventPrompt(r, opts = {}) {
 return { EVENT_PROMPT_VERSION, ASK_KINDS, buildEventPrompt };
 })();
 
+__mods['plain-summary'] = (function () {
+// 盘面顶部的那段「人话总结」：把已经算出来的结构，翻译成一段不用术语也能读的话。
+//
+// 为什么单独成文件、而不是塞进 interpret：
+// 1) interpret 是「解析」，回答的是「凭什么这么判」，一屏几十条，普通人第一眼读不动；
+// 2) 这里是「先说什么」，只讲四件事——底色、感情、卡点、怎么办，每条都必须指回盘面上的某个事实；
+// 3) 它必须是纯函数：同一张盘每次生成的文字完全一样，不能有随机、不能有「大概」「可能很准」这类含糊。
+//
+// 一条硬规矩：这里只做「结构 → 人话」的翻译，不做吉凶断语。
+// 「官杀混」可以说成「你容易遇到两种类型的人」，不能说成「你婚姻不好」。
+
+const { ASK_KINDS } = (__mods['event-prompt'] || {});
+const { PALACE_FIELD, GATE_MEANING } = (__mods['qimen-prompt'] || {});
+
+const ASK = ASK_KINDS || {};
+const PALACE = PALACE_FIELD || {};
+const GATES = GATE_MEANING || {};
+
+// 命盘的「询问方向」与问事提示的「六类问法」不是一套键：
+// 财运要落到「生意/合作」、学业落到「工作/事业」、健康与出行各自归位。
+// 不转这一道，选「财运」问六爻时会取不到现实核对清单——建议那一段就是空的。
+const DIR2KIND = { wealth: 'business', career: 'career', love: 'love', health: 'other', study: 'career', travel: 'action', general: 'other' };
+const askKind = (dir) => DIR2KIND[dir] || (ASK[dir] ? dir : 'other');
+
+const ELEMENT_COLOR = {
+  木: { color: '青、绿', where: '东边、有树有水的地方', daily: '早上多出门走走' },
+  火: { color: '红、橙、紫', where: '南边、向阳的房间', daily: '白天多晒太阳，别总待在阴冷的屋里' },
+  土: { color: '黄、棕、米色', where: '中原地带、干爽高燥处', daily: '把作息和吃饭时间固定下来' },
+  金: { color: '白、银、浅灰', where: '西边、通风利落的地方', daily: '把该断的事断干净，别拖' },
+  水: { color: '黑、深蓝', where: '北边、临水处', daily: '留出独处和放空的时间' },
+};
+
+const GOD_PLAIN = {
+  正印: '靠吸收和消化来获得安全感，习惯先想明白再动',
+  偏印: '想得比说得多，一件事会在心里推演出很多种可能',
+  正官: '对规矩和责任敏感，别人一句交代会变成自己的压力',
+  七杀: '对压力和竞争敏感，遇强则强，也容易被强势的人吸引',
+  正财: '对现实条件敏感，不太会被空话打动',
+  偏财: '对机会敏感，愿意为看得见的回报承担风险',
+  食神: '表达温和，喜欢把日子过得有滋味',
+  伤官: '有自己的标准，看不上粗糙的东西，容易先挑毛病',
+  比肩: '自我边界清楚，不太愿意被安排',
+  劫财: '同辈之间容易较劲，也容易替朋友出头',
+};
+
+const STAGE_PLAIN = {
+  长生: '刚起步，有生机',
+  沐浴: '不安定，容易被外界牵动',
+  冠带: '在成形，开始要面子',
+  临官: '正当力，能扛事',
+  帝旺: '很足，但也容易过满',
+  衰: '开始收力，做事偏保守',
+  病: '使不上劲，需要借外力',
+  死: '静态，不爱主动',
+  墓: '收着、藏着，不爱外露',
+  绝: '在这里使不上劲，容易觉得被压着',
+  胎: '还在孕育，慢热',
+  养: '在积攒，等时机',
+};
+
+const STAR_PLAIN = {
+  紫微: '要主导、在意体面',
+  天机: '脑子转得快，爱盘算',
+  太阳: '愿意给出去，也容易被消耗',
+  武曲: '务实，认结果',
+  天同: '图安稳，怕冲突',
+  廉贞: '要强，情绪起伏大',
+  天府: '稳，能存住东西',
+  太阴: '细腻，心思藏在里面',
+  贪狼: '欲望强、多才多艺',
+  巨门: '爱辨析，也容易生口舌',
+  天相: '会配合，擅长讲和',
+  天梁: '老成，愿意护着别人',
+  七杀: '独断，敢冲',
+  破军: '破旧立新，不安于现状',
+};
+
+const BRIGHT_PLAIN = { 庙: '得力', 旺: '得力', 得地: '还算得力', 平: '一般', 陷: '不太稳' };
+
+const uniq = (arr) => [...new Set(arr.filter(Boolean))];
+
+const MONTH_SEASON = {
+  寅: '初春', 卯: '仲春', 辰: '暮春', 巳: '初夏', 午: '盛夏', 未: '长夏',
+  申: '初秋', 酉: '仲秋', 戌: '深秋', 亥: '初冬', 子: '仲冬', 丑: '隆冬',
+};
+
+/** 取日支（配偶宫）与年/月/时支之间的破、冲、合、害 */
+function branchLinks(relations, dayBranch) {
+  const out = { po: [], chong: [], he: [] };
+  for (const t of (relations && relations.branches) || []) {
+    if (!dayBranch || !String(t).includes(dayBranch)) continue;
+    if (/破/.test(t)) out.po.push(t);
+    else if (/冲/.test(t)) out.chong.push(t);
+    else if (/合/.test(t)) out.he.push(t);
+  }
+  return out;
+}
+
+function baziSummary(r) {
+  const P = r.pillars || {};
+  const day = P.day || {};
+  const month = P.month || {};
+  const dm = r.dayMaster || {};
+  const cl = r.climate || {};
+  const gender = (r.input && r.input.gender) || 'female';
+  const topGods = Object.entries((r.frame && r.frame.godStats && r.frame.godStats.groups) || {})
+    .filter(([, v]) => v > 0).sort((a, b) => b[1] - a[1]);
+  const godNames = (r.frame && r.frame.yongshen && r.frame.yongshen.favorTenGods) || [];
+  const favor = (r.frame && r.frame.yongshen && r.frame.yongshen.favor) || [];
+  const avoid = (r.frame && r.frame.yongshen && r.frame.yongshen.avoid) || [];
+
+  // ── 总纲：日主 + 生月 + 冷暖 + 缺什么 ──
+  const season = MONTH_SEASON[month.branch] || `${month.branch}月`;
+  const climateWord = cl.label === '寒湿' ? '天寒水旺，木像冬天的藤，不是不强，是冷得伸展不开'
+    : cl.label === '燥热' ? '火土偏燥，像久旱的地，需要水和湿气来松一松'
+      : '寒暖相对均衡，没有极端的偏枯';
+  const needEl = (cl.need && cl.need.element) || favor[0] || '';
+  const lead = `${dm.stem || ''}${dm.element || ''}日主，生在${season}${month.branch || ''}月：${climateWord}。`
+    + `${needEl ? `最需要的是${needEl}${cl.need && cl.need.why ? `——${cl.need.why}` : ''}。` : ''}`
+    + `整体${r.strength ? r.strength.level : '中和'}，不是极旺也不是极弱，所以${r.strength && r.strength.level === '身弱' ? '很多事要靠外部条件配合，硬扛不如借力' : '撑得住，关键是别把力气用在错的地方'}。`;
+
+  // ── 底色：十神权重前两位 ──
+  const top2 = topGods.slice(0, 2).map(([k]) => k);
+  // 具体到哪一个十神：优先取盘上真出现的那个（天干 + 藏干本气），
+  // 否则「食伤偏重」会把伤官说成食神——两者的人话差得远。
+  const present = [];
+  for (const p of Object.values(P)) {
+    if (!p) continue;
+    if (p.stemTenGod) present.push(p.stemTenGod);
+    if (p.hidden && p.hidden[0] && p.hidden[0].tenGod) present.push(p.hidden[0].tenGod);
+  }
+  const godSentences = top2.map((g) => {
+    const inner = { 印: ['正印', '偏印'], 官杀: ['正官', '七杀'], 食伤: ['食神', '伤官'], 财: ['正财', '偏财'], 比劫: ['比肩', '劫财'] }[g] || [];
+    const hit = inner.find((x) => present.includes(x)) || inner[0];
+    return hit && GOD_PLAIN[hit] ? `${g}偏重：${GOD_PLAIN[hit]}。` : '';
+  }).filter(Boolean);
+  const basics = `${godSentences.join('')}${godNames.length ? '' : ''}` +
+    (top2.includes('印') ? '想得多是你的默认状态，好处是稳，代价是慢和累。' : '');
+
+  // ── 感情：女命看官杀、男命看财 ──
+  const spouseGods = gender === 'female' ? ['正官', '七杀'] : ['正财', '偏财'];
+  const spouseName = gender === 'female' ? '官杀（正官与七杀）' : '财星（正财与偏财）';
+  const positions = { year: '年干', month: '月干', day: '日干', hour: '时干' };
+  const exposed = Object.entries(P)
+    .filter(([, p]) => p && spouseGods.includes(p.stemTenGod))
+    .map(([k, p]) => `${positions[k]}${p.stemTenGod}`);
+  const dayHiddenGod = (day.hidden && day.hidden[0] && day.hidden[0].tenGod) || '';
+  const links = branchLinks(r.relations, day.branch);
+  const loveBits = [];
+  loveBits.push(`${gender === 'female' ? '女命' : '男命'}看配偶星取${spouseName}${exposed.length ? `，${exposed.join('、')}` : '，盘中未透干'}` +
+    `${exposed.length ? '——摆在明处，说明这件事在你生活里是绕不开的主题' : '——不显在明处，往往要靠后天遇到的人把它带出来'}。`);
+  if (dayHiddenGod) loveBits.push(`日支（配偶宫）坐${day.branch}${dayHiddenGod}${day.dishi ? `，日主在这里是「${day.dishi}」：${STAGE_PLAIN[day.dishi] || ''}` : ''}。`);
+  if (links.po.length) loveBits.push(`日支与另一支相破（${links.po.join('、')}）：破不是吵架，是那种说不清、解释不明白的暗耗，容易冷处理。`);
+  if (links.chong.length) loveBits.push(`日支逢冲（${links.chong.join('、')}）：关系里变动感强，聚散、异地、节奏不一致都可能出现。`);
+  if (links.he.length) loveBits.push(`日支有合（${links.he.join('、')}）：容易被关系拴住，进去了就不太想出来。`);
+  if (r.hourUnknown) loveBits.push('时柱暂缺，所以「子女」这一路的信息读不出，感情结论也就少了三分之一。');
+
+  // ── 卡点：破冲 + 伤官见官 + 印重内耗 ──
+  const gejuNames = ((r.frame && r.frame.geju) || []).map((g) => g.name);
+  const stucks = [];
+  if (links.po.length) stucks.push('破在日支：最伤人的往往不是大事，是没说开的小事。');
+  if (gejuNames.includes('伤官见官')) stucks.push('盘里有「伤官见官」的组合：既想要稳定，又忍不了对方的毛病，这是同一件事的两面。');
+  if (top2.includes('印') && !top2.includes('财')) stucks.push('印重而财轻：想得多、落得少；越焦虑越容易继续想。');
+  if (!stucks.length) stucks.push('这一盘没有特别尖锐的冲克，卡点更多在「节奏」上——什么时候该动，什么时候该停。');
+
+  // ── 建议 ──
+  const advice = [];
+  if (needEl && ELEMENT_COLOR[needEl]) {
+    const c = ELEMENT_COLOR[needEl];
+    advice.push(`多接触${needEl}：${c.color}这类颜色、${c.where}，日常可以${c.daily}。`);
+  }
+  if (avoid.length) advice.push(`少把自己放在${avoid.slice(0, 2).join('、')}过重的环境里——不是不能碰，是别长期待在那种氛围中。`);
+  if (top2.includes('印')) advice.push('给「想」设个时限：一件事想超过十分钟还没结论，就先做一个最小动作，用行动换信息。');
+  if (gejuNames.includes('伤官见官')) advice.push('把标准用在事情上，不要用在人身上；对人提要求之前，先说清你需要什么。');
+
+  return {
+    system: 'bazi',
+    title: '先看这一张：这张盘大致在说什么',
+    chips: uniq([`${dm.stem || ''}${dm.element || ''}日主`, `${month.branch || ''}月`, cl.label || '', r.strength ? r.strength.level : '', r.hourUnknown ? '时柱暂缺' : '']),
+    lead,
+    sections: [
+      { h: '你的底色', t: basics || '结构比较均衡，没有一边倒的偏重。' },
+      { h: '感情这件事', t: loveBits.join('') },
+      { h: '最容易卡住的地方', t: stucks.join('') },
+    ],
+    advice,
+    caveat: r.hourUnknown
+      ? '时柱暂缺：以上只据年、月、日六个字，等于全盘信息的七成左右。子女缘分、晚年走势、以及「内心最深处那一层」都读不全，结论只作参考。'
+      : '',
+    footer: '以上都是对结构的描述，不是断语；判断好坏要结合你自己的处境。',
+  };
+}
+
+function ziweiSummary(r) {
+  const pal = (r.palaces || []);
+  const ming = pal[0] || {};
+  const body = r.body || {};
+  const mainStars = (ming.stars || []).filter((s) => s.type === '主星');
+  const bodyPalace = pal.find((p) => p.isBody) || {};
+  const love = pal.find((p) => p.palace === '夫妻') || {};
+  const mainName = mainStars.map((s) => s.name).join('、') || '空宫（借对宫）';
+  const bright = mainStars.map((s) => BRIGHT_PLAIN[s.brightness] || '').filter(Boolean)[0] || '';
+  const plainOf = (stars) => stars.filter((s) => s.type === '主星').map((s) => `${s.name}${STAR_PLAIN[s.name] ? `（${STAR_PLAIN[s.name]}）` : ''}`).join('；');
+
+  const ps = r.patternSummary || {};
+  const broken = uniq(ps.broken || []);
+  const bad = uniq(ps.bad || []);
+  // 被判冲破的格局不再算「成」——否则同一段里既说成、又说破，读的人只会觉得自相矛盾
+  const formed = uniq([...(ps.good || []), ...(ps.neutral || [])]).filter((x) => !broken.includes(x));
+  const loveStars = (love.stars || []);
+  const loveMain = loveStars.filter((s) => s.type === '主星');
+  const loveSha = loveStars.filter((s) => s.type === '煞星');
+
+  return {
+    system: 'ziwei',
+    title: '先看这一张：这张盘大致在说什么',
+    chips: uniq([`命宫在${ming.branch || ''}`, mainName, r.bureau ? r.bureau.name : '', body.lands ? `身宫落${body.lands}` : '']),
+    lead: `命宫在${ming.branch || ''}，坐${mainName}${bright ? `（${bright}）` : ''}；身宫落在${body.lands || body.palace || '—'}。`
+      + `${mainStars.length ? `底色是${mainStars.map((s) => STAR_PLAIN[s.name] || s.name).join('、')}。` : '命宫无主星，性格更多由对宫与三方决定，可塑性反而大。'}`
+      + `${formed.length ? `结构上成的是${formed.slice(0, 3).join('、')}——格局只说明形状，不是吉凶判词。` : '没有完整成套的格局，这一盘更多看单颗星的性质，少看组合。'}`,
+    sections: [
+      { h: '你的底色', t: `${plainOf(ming.stars || []) || '命宫无主星，靠三方四正补'}。身宫落${body.lands || '—'}，说明你这辈子真正花力气的地方在${body.lands || '那一块'}。` },
+      { h: '感情这件事', t: `夫妻宫在${love.branch || '—'}，坐${loveMain.map((s) => `${s.name}${s.brightness ? `（${BRIGHT_PLAIN[s.brightness] || s.brightness}）` : ''}`).join('、') || '空宫（借对宫）'}。`
+        + `${loveSha.length ? `同宫还有${loveSha.map((s) => s.name).join('、')}——关系里容易起摩擦，来得快也去得快。` : '没有明显的煞星同宫，关系相对平顺。'}` },
+      { h: '最容易卡住的地方', t: `${broken.length ? `被冲破的格局有${broken.join('、')}——结构还在，但成色打折；冲不等于毁，说的是它不如完好时那么顶用。` : '主要格局没有明显被冲破。'}`
+        + `${bad.length ? `另有${bad.join('、')}这类忌格，只描述结构，不作吉凶断。` : ''}` },
+    ],
+    advice: [
+      `命宫主星${mainStars.length ? `是${mainStars.map((s) => s.name).join('、')}，顺它的长处在做事，比硬改性格省力` : '不显，先靠环境和习惯替自己定节奏'}。`,
+      `身宫落${body.lands || '—'}：这块是你真正在意的地方，也是容易耗人的地方，留出余量。`,
+    ],
+    caveat: '',
+    footer: '以上都是对结构的描述，不是断语；判断好坏要结合你自己的处境。',
+  };
+}
+
+// ── 问事类与走势：同样只翻译结构 ─────────────────────────────
+// 命盘讲「你是什么结构」，问事讲「这件事现在卡在哪、下一步看什么」。
+// 共同底线一致：每条话都要能指回盘面上的某个符号，不写「一定会」「必然」。
+
+const MONTH_STATE_PLAIN = { 旺: '当令，气最足', 相: '有生机，正在起', 休: '气在泄，歇着', 囚: '被压着，使不上劲', 死: '最弱，得靠外援' };
+const LIUQIN_PLAIN = {
+  官鬼: '职位、压力、管你的人和事',
+  妻财: '钱、资源、实际回报',
+  父母: '文书、答复、流程与长辈',
+  子孙: '结果本身、松弛、把事情落地',
+  兄弟: '同辈、分利、竞争',
+};
+const DAY_REL_PLAIN = {
+  日生: '日辰生它，当天有人托着',
+  日克: '日辰克它，当天被压一头',
+  比和: '与日辰同气，力量相当',
+  日合: '与日辰相合，黏住了',
+  日冲: '与日辰相冲，当天就动',
+};
+
+/** 用神/世爻的「当下状态」：月令一句 + 日辰一句 + 空/动/冲的标志 */
+function stateLine(l) {
+  if (!l) return '';
+  const bits = [];
+  const ms = MONTH_STATE_PLAIN[l.monthState] || l.monthSay || '';
+  if (ms) bits.push(`月令${l.monthState || ''}（${ms}）`);
+  const ds = DAY_REL_PLAIN[l.dayRelation] || l.daySay || '';
+  if (ds) bits.push(ds);
+  if (l.kong) bits.push('旬空——抓不实，等冲或填');
+  if (l.moving) bits.push('发动，是这件事的动因');
+  if (l.monthChong) bits.push('月破，先破后立');
+  return bits.join('；');
+}
+
+/**
+ * 六爻在「没指定所问之事」时的版本。
+ *
+ * 取用神要先知道问什么；方向留在「综合」时，引擎给不出用神，也就给不出成败。
+ * 但一张卦并非只能读懂用神——世应、卦体（六冲/六合）、动爻这几样与问题无关，照样能读。
+ * 所以这里不硬凑一个用神，只讲这几样，并在结尾把「为什么没有结论」说清楚：
+ * 让用户知道该补一步（选方向），而不是以为插件什么都说不出来。
+ */
+function liuyaoGeneralSummary(r) {
+  const hex = (r.hexStrength && r.hexStrength.lines) || [];
+  if (!hex.length) return null;
+  const shi = hex.find((l) => l.shi) || null;
+  const ying = hex.find((l) => l.ying) || null;
+  const body = r.body || {};
+  const ben = body.ben || {};
+  const bian = body.bian || {};
+  const moving = (r.cast && r.cast.movingPositions) || [];
+  const movingLines = hex.filter((l) => l.moving);
+  const q = String(r.question || '').trim();
+  const labels = uniq([...(body.labels || []), ...((r.hexStrength && r.hexStrength.labels) || [])]);
+  const month = r.hexStrength && r.hexStrength.month ? r.hexStrength.month.branch : '';
+
+  const form = [
+    ben.chong ? '六冲卦：事情容易散、节奏快' : '',
+    ben.he ? '六合卦：事情黏住、快不起来' : '',
+    body.fuYin && (body.fuYin.inner || body.fuYin.outer) ? '有伏吟：原地打转' : '',
+    body.fanYin && (body.fanYin.inner || body.fanYin.outer) ? '有反吟：来回反复' : '',
+  ].filter(Boolean);
+
+  return {
+    system: 'liuyao',
+    title: '先看这一卦：这卦大致在说什么',
+    chips: uniq([ben.name, bian.name ? `变${bian.name}` : '', moving.length ? `${moving.length} 爻动` : '静卦', month ? `${month}月` : '']),
+    lead: `${q ? `你问的是「${q}」。` : ''}本卦「${ben.name || '—'}」${bian.name ? `，${moving.length ? `第 ${moving.join('、')} 爻动` : '六爻安静'}，变「${bian.name}」` : ''}。`
+      + `方向还留在「综合」，所以这一卦没有取用神——先只讲与问题无关的那几样：你（世爻）、事情（应爻）、卦体。`,
+    sections: [
+      { h: '代表你的是', t: shi ? `世爻在${shi.name}（${shi.branch}${shi.element}·${shi.liuqin}）：${stateLine(shi) || '状态平稳'}。` : '这一卦取不到世爻。' },
+      { h: '代表事情的是', t: ying ? `应爻在${ying.name}（${ying.branch}${ying.element}·${ying.liuqin}）：${stateLine(ying) || '状态平稳'}。应爻说的是「事情那一头」的状态，不是你努力的程度。` : '这一卦取不到应爻。' },
+      { h: '卦体与动爻', t: `${form.length ? `${form.join('；')}。` : '没有六冲、六合、伏吟、反吟这类整体结构。'}`
+        + `${movingLines.length ? `动爻在${movingLines.map((l) => `${l.name}（${l.liuqin}）`).join('、')}——动的地方，就是这件事会发生变化的那一环。` : '六爻安静：眼下没有明显在动的地方，说明事情的节奏还没起来。'}` },
+    ],
+    advice: [
+      '先在上面选一个「询问方向」（工作、感情、生意、推进、择日）：选完才会取用神，旺衰、应期、成败条件才有落点。',
+      ...((ASK.other && ASK.other.reality) || []).slice(0, 2),
+    ].filter(Boolean),
+    caveat: '未指定所问之事：这一版只读世应、卦体与动爻，不判成败，也不给应期——不是算不出来，是取用神要先知道问什么。',
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+function liuyaoSummary(r) {
+  const ug = r.useGod || {};
+  // 没有用神（方向停在「综合」）时走世应版，不让第一屏空着
+  if (!ug.liuqin) return liuyaoGeneralSummary(r);
+  const found = ug.found || [];
+  if (!found.length && !ug.missing) return null;
+  const q = String(r.question || '').trim();
+  const strengthLines = (r.useGodStrength && r.useGodStrength.lines) || [];
+  const byPos = (pos) => strengthLines.find((l) => l.position === pos) || null;
+  const hexLines = (r.hexStrength && r.hexStrength.lines) || [];
+  const shi = hexLines.find((l) => l.shi) || null;
+  const month = r.useGodStrength && r.useGodStrength.month ? r.useGodStrength.month.branch : '';
+  const day = (r.dayGanZhi && r.dayGanZhi.name) || '';
+
+  const positions = found.map((f) => f.name).join('、');
+  const lead = `${q ? `你问的是「${q}」。` : '你没填具体问题，这里按「综合」取用神，结论会更粗。'}`
+    + `这卦里代表它的是「${ug.liuqin}」（${ug.ask || ''}），`
+    + (found.length
+      ? `落在${positions}${found.length > 1 ? '——两处都出现了，两个条件要一起看' : ''}。`
+      : '盘中看不见它（伏藏），要等冲开或引出才有动静。')
+    + `日辰是${day || '—'}，月建是${month || '—'}。`;
+
+  const favors = [];
+  const burdens = [];
+  for (const f of found) {
+    const st = byPos(f.position);
+    if (!st) continue;
+    if (/旺|相/.test(st.monthState || '') && !st.kong && !st.monthChong) favors.push(f.name);
+    if (/日克|日冲/.test(st.dayRelation || '') || st.kong || st.monthChong) burdens.push(f.name);
+  }
+  const balance = found.length
+    ? (favors.length > burdens.length ? '条件偏有利'
+      : burdens.length > favors.length ? '条件偏紧，得有外力或时间'
+        : '一半一半，取决于你怎么推')
+    : '没有可判的落点';
+
+  const flags = uniq([
+    ...(ug.labels || []).filter((x) => /两现|伏藏|六合|六冲/.test(x)),
+    r.body && r.body.ben && r.body.ben.chong ? '六冲卦：事情容易散，节奏偏快' : '',
+    r.body && r.body.ben && r.body.ben.he ? '六合卦：事情黏住，快不起来' : '',
+  ]);
+
+  const yingqiBranches = uniq(((r.yingqi && r.yingqi.items) || []).map((x) => x.branch)).slice(0, 4);
+
+  return {
+    system: 'liuyao',
+    title: '先看这一卦：这卦大致在说什么',
+    chips: uniq([r.ben && r.ben.name, `用神 ${ug.liuqin || ''}`, month ? `${month}月` : '', r.yingqi ? r.yingqi.tempo : '']),
+    lead,
+    sections: [
+      { h: '代表你的是', t: shi ? `世爻在${shi.name}（${shi.branch}${shi.element}·${shi.liuqin}）：${stateLine(shi) || '状态平稳'}。` : '这一卦的世爻取不到，先看用神那一条。' },
+      { h: '代表这件事的是', t: found.length
+        ? found.map((f) => `${f.name} ${f.ganzhi}（${f.liuqin}）：${stateLine(byPos(f.position)) || '没有明显的月日冲克'}。`).join('')
+        : '用神伏藏：盘中看不见它，说明这件事现在还不在明面上，要等一个引子。' },
+      { h: '成不成看哪里', t: `把用神的月令与日辰放在一起，盘面给的是「${balance}」。${flags.length ? `另有：${flags.join('；')}。` : ''}` },
+    ],
+    advice: [
+      ...((ASK[askKind(ug.direction)] && ASK[askKind(ug.direction)].reality) || []).slice(0, 2),
+      yingqiBranches.length ? `应期只看地支：${yingqiBranches.join('、')}——地支只是「往哪个方向等」，不是公历日期。` : '',
+    ].filter(Boolean),
+    caveat: uniq([
+      found.length > 1 ? `用神两现（${positions}）：本插件不替你二选一，两处条件一起看。` : '',
+      ug.missing ? '用神伏藏：先看伏神与飞神的关系，再看有没有东西把它冲出来。' : '',
+      '世应只说明「你」和「事」的相对位置，不直接等于吉凶。',
+    ]).join(''),
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+function meihuaSummary(r) {
+  const bu = r.bodyUse;
+  if (!bu || !bu.body || !bu.use) return null;
+  const q = String(r.question || '').trim();
+  return {
+    system: 'meihua',
+    title: '先看这一卦：方向大致在哪',
+    // 标签写体用关系（谁给谁力），不把「大吉」顶在最前面：
+    // 引擎的 level 是条件层面的刻度，放到标题旁边就会被读成结果。
+    chips: uniq([r.ben && r.ben.name, r.bian && `变${r.bian.name}`, bu.relation ? `体用 ${bu.relation.split('（')[0]}` : '']),
+    lead: `${q ? `你问的是「${q}」。` : ''}本卦「${r.ben && r.ben.name}」，动在第 ${r.moving} 爻，变卦「${r.bian && r.bian.name}」。`
+      + `体卦 ${bu.body.trigram}（${bu.body.element}）代表你，用卦 ${bu.use.trigram}（${bu.use.element}）代表这件事：${bu.relation}。`,
+    sections: [
+      { h: '过程与结果', t: `过程看互卦「${(r.hu && r.hu.name) || '—'}」，结果看变卦「${(r.bian && r.bian.name) || '—'}」。梅花给的是方向，不是细节——它不会告诉你几号、多少钱。` },
+      { h: '盘面给的分量', t: `这一卦的体用关系被标成「${bu.level}」。注意：这是条件层面的判断，不是结果已经发生；条件好但不动，一样没有结果。` },
+    ],
+    advice: [
+      '把它当「换个角度看这件事」：体用只分「谁在给、谁在耗」，剩下要你自己补具体动作。',
+      '如果要推进，先定一个最小动作（打个电话、发条消息），别等条件齐了再动。',
+    ],
+    caveat: '梅花取象的自由度大：同一卦，不同人读出的细节可以不同。本插件只取体用生克这一层。',
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+function daliurenSummary(r) {
+  const sc = r.sanChuan || {};
+  if (!sc.chu || !sc.zhong || !sc.mo) return null;
+  const q = String(r.question || '').trim();
+  const say = (c) => `${c.zhi}（${c.liuQin || ''}·${c.jiangFull || ''}）`;
+  const plain = (c) => (LIUQIN_PLAIN[c.liuQin] ? `——${LIUQIN_PLAIN[c.liuQin]}` : '');
+  return {
+    system: 'daliuren',
+    title: '先看这一课：事情怎么走到这一步',
+    chips: uniq([r.geJu && r.geJu.name, `${sc.chu.zhi}→${sc.mo.zhi}`, r.yueJiang && `月将${r.yueJiang.zhi}`]),
+    lead: `${q ? `你问的是「${q}」。` : ''}三传是 ${sc.chu.zhi} → ${sc.zhong.zhi} → ${sc.mo.zhi}；`
+      + `末传落 ${sc.mo.zhi}（${sc.mo.liuQin || ''}·${sc.mo.jiangFull || ''}），课体是「${(r.geJu && r.geJu.name) || '—'}」。`,
+    sections: [
+      { h: '起手（初传）', t: `${say(sc.chu)}${plain(sc.chu)}。这是事情开头的样子。` },
+      { h: '转折（中传）', t: `${say(sc.zhong)}${plain(sc.zhong)}。中间会经过这一段，也是容易改道的地方。` },
+      { h: '落点（末传）', t: `${say(sc.mo)}${plain(sc.mo)}。末传比初传更接近结果——但也只是「照现在这样走下去会到哪」。` },
+    ],
+    advice: [
+      '先看初传：事情是从哪儿起的？把那个起点找出来，比猜结果有用。',
+      '中传若与初传相冲相克，说明中途会变；这时别把计划定死。',
+    ],
+    caveat: '三传讲的是传变形态，不给具体日期；同一课不同流派对课体的命名也有差异。',
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+function qimenSummary(r) {
+  const dayGan = r.siZhu && r.siZhu.day ? String(r.siZhu.day)[0] : '';
+  const hourGan = r.siZhu && r.siZhu.time ? String(r.siZhu.time)[0] : '';
+  const palaces = r.palaces || [];
+  if (!palaces.length) return null;
+  const findStem = (g) => palaces.find((p) => p.tianPan === g)
+    || (r.centerPalace && r.centerPalace.tianPan === g ? r.centerPalace : null);
+  const mine = findStem(dayGan);
+  const thing = findStem(hourGan);
+  const q = String(r.question || '').trim();
+  // 「6宫」是给人看的界面里最别扭的一种写法：读奇门的人认的是乾宫、巽宫。
+  // 宫名从 PALACE_FIELD 的释义里取（「乾宫：…」），取不到再退回数字。
+  const pName = (p) => {
+    const f = p && PALACE[p.palace] && PALACE[p.palace].field;
+    return f ? f.split('：')[0] : (p ? `${p.palace}宫` : '盘中取不到');
+  };
+  const pDir = (p) => (p && PALACE[p.palace] && PALACE[p.palace].dir ? `（${PALACE[p.palace].dir}）` : '');
+  const cell = (p) => (p ? `${pName(p)}${pDir(p)}｜${p.gate || '—'}·${p.star || '—'}·${p.god || '—'}` : '盘中取不到');
+  const rel = (p) => {
+    if (!p || !p.gateRelation || !p.gateRelation.type) return '门与宫的关系没算到';
+    return `${p.gateRelation.type}（${p.gateRelation.note || ''}）`;
+  };
+  return {
+    system: 'qimen',
+    title: '先看这一局：条件和位置在哪',
+    // r.ju 已经含「阴遁/阳遁」，再单列一个「阴遁」标签是重复信息，占位置不增信息
+    chips: uniq([r.ju, r.zhiFu && `值符${r.zhiFu.star}`]),
+    lead: `${q ? `你问的是「${q}」。` : ''}日干 ${dayGan} 落在${cell(mine)}，时干 ${hourGan} 落在${cell(thing)}——前者代表你，后者代表这件事。`
+      + `你这边门与宫是${rel(mine)}；事情那边是${rel(thing)}。`,
+    sections: [
+      { h: '你这边的条件', t: mine
+        ? `你在${PALACE[mine.palace] ? PALACE[mine.palace].field : mine.palace + '宫'}；门是${mine.gate || '—'}——${GATES[mine.gate] || '门名只说明形态'}。`
+        : '日干落在中宫或取不到：中宫无门无神，按寄宫（多寄坤二）取用，读的时候要说清这是寄宫。' },
+      { h: '事情那边的条件', t: thing
+        ? `事情落在${PALACE[thing.palace] ? PALACE[thing.palace].field : thing.palace + '宫'}；门是${thing.gate || '—'}——${GATES[thing.gate] || '门名只说明形态'}。`
+        : '时干落在中宫或取不到，同样按寄宫看，别当成坤二本宫。' },
+      { h: '门名不是吉凶', t: '开门主启动、生门主生长、休门主等待、伤门主损耗、杜门主隐藏——这些说的是「这件事现在是什么形态」，不是好坏判决。要看它与日干宫、时干宫的生克。' },
+    ],
+    advice: [
+      '把「我这边」和「事情那边」的宫位对一下：两边相距越远，越需要中间人、流程或时间。',
+      '如果门名是伤门、死门，不是叫你别做，而是提醒这件事的代价和收尾要先想清楚。',
+    ],
+    caveat: uniq([r.juMethodNote || '', '奇门重方位与时机；本插件不给具体方位建议，只把宫位与门星神摊开。']).join(''),
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+function tarotSummary(r) {
+  const cards = r.cards || [];
+  if (!cards.length) return null;
+  const q = String(r.question || '').trim();
+  // 「关节」取当下那一张（牌阵里通常叫现在/现况/建议），没有就取中间一张。
+  // 以前取的是「第一张逆位」，那是随机的——同一副牌换个抽牌顺序，结论就换了个位置。
+  const pivot = cards.find((c) => /现在|现况|当下|建议|核心/.test(c.position || ''))
+    || cards[Math.floor(cards.length / 2)];
+  return {
+    system: 'tarot',
+    title: '先看这几张牌：它们各在说什么',
+    // spread 里已经写了「3 张牌阵（过去/现在/未来）」，再挂一个「3 张」是重复
+    chips: uniq([r.spread]),
+    lead: `${q ? `你问的是「${q}」。` : ''}${r.spread || ''}：`
+      + cards.map((c) => `${c.position}「${c.name}」${c.orientation}`).join('，') + '。',
+    sections: cards.slice(0, 4).map((c) => ({
+      h: c.position,
+      t: `「${c.name}」${c.orientation}：${(c.keywords || []).slice(0, 3).join('、') || c.core || ''}。${c.positionHint || ''}`,
+    })),
+    advice: [
+      `最值得先看的是「${pivot.name}」（${pivot.position}·${pivot.orientation}）——${(pivot.keywords || []).slice(0, 3).join('、') || '它所在的位置，就是这件事现在的着力点'}。`,
+      '把牌当镜子：它给的是看事情的角度，不是判决。看完写一句「那我下一步做什么」。',
+    ],
+    caveat: r.systemNote || '塔罗为象征系统，牌义与元素对应存在流派差异。',
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+function hepanSummary(r) {
+  const sc = r.score;
+  if (!sc) return null;
+  const dims = (r.dimensions || []).filter((d) => d && d.text);
+  // 合盘里 dayMaster 是「丁火」这样的一整串，不是 {stem,element}；两种写法都接住，
+  // 否则标签会渲染成 undefinedundefined，比不给还难看。
+  const name = (x) => {
+    const dm = x && x.dayMaster;
+    if (!dm) return '';
+    if (typeof dm === 'string') return dm.replace(/日主$/, '');
+    return `${dm.stem || ''}${dm.element || ''}`;
+  };
+  const a = name(r.a);
+  const b = name(r.b);
+  return {
+    system: 'hepan',
+    title: '先看这一张：你们大致怎么相处',
+    chips: uniq([a && b ? `${a} × ${b}` : '', sc.level, `${sc.total}/100`]),
+    lead: `${a && b ? `你们是 ${a} 与 ${b}。` : ''}合盘描述的是「相处方式与互补点」，不判合不合，也不决定关系成败。`
+      + `整体上盘面给的是「${sc.level}」（${sc.total}/100——分数只是相对刻度，不是及格线）。`,
+    sections: dims.slice(0, 3).map((d) => ({ h: d.label, t: d.text })),
+    advice: [
+      '一起看，别一个人看完拿去判断对方：前者是对话，后者是审判。',
+      '把上面的分歧当话题清单：哪一条你们真的在意，就聊哪一条。',
+    ],
+    caveat: (r.notes && r.notes[0]) || '合盘看的是相处方式与互补点，不决定关系成败。',
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+function trendSummary(r) {
+  const pts = r.points || [];
+  const segs = r.segments || [];
+  if (!pts.length || !segs.length) return null;
+  // 「现在」由调用方传进来的 asOf 决定（meta.nowYear），不读挂钟：
+  // 同一条线在任何时候重新生成，文字必须一模一样。
+  const nowYear = Number.isInteger(r.meta && r.meta.nowYear) ? r.meta.nowYear : null;
+  const cur = nowYear ? (pts.find((p) => p.year === nowYear) || null) : null;
+  const seg = cur
+    ? (segs.find((s) => cur.age >= s.startAge && cur.age <= s.endAge) || segs[0])
+    : segs[0];
+  const next = segs[segs.indexOf(seg) + 1];
+  const inSeg = pts.filter((p) => p.age >= seg.startAge && p.age <= seg.endAge);
+  const avg = inSeg.length ? inSeg.reduce((n, p) => n + p.score, 0) / inSeg.length : 0;
+  const allAvg = pts.reduce((n, p) => n + p.score, 0) / pts.length;
+  const tone = avg >= allAvg + 5 ? '比一生平均更亮' : avg <= allAvg - 5 ? '比一生平均更闷' : '与一生平均差不多';
+  const best = (r.highlights && r.highlights.best) || [];
+  const worst = (r.highlights && r.highlights.worst) || [];
+  const nowLine = cur
+    ? `你现在 ${cur.age} 岁（${nowYear} 年），在「${seg.ganZhi}」这一步的第 ${cur.age - seg.startAge + 1} 年（${seg.startAge}–${seg.endAge} 岁）`
+      + `${next ? `，再过 ${seg.endAge - cur.age + 1} 年到 ${next.startAge} 岁换「${next.ganZhi}」` : '，已是最后一步'}。`
+    : `没给当前日期（asOf），所以不标「现在在第几步」；先看第一步「${seg.ganZhi}」（${seg.startAge}–${seg.endAge} 岁）起手的样子。`;
+  return {
+    system: 'trend',
+    title: '先看这一条线：这些年大致什么走势',
+    chips: uniq([seg.ganZhi, `${seg.startAge}–${seg.endAge} 岁`, cur ? `${cur.age} 岁` : '']),
+    lead: `这条线按 ${(r.meta && r.meta.toAge) || pts.length} 岁排到 ${pts[pts.length - 1].year} 年，共 ${segs.length} 步大运。`
+      + nowLine,
+    sections: [
+      { h: '这一步的基调', t: `这一步里各年的平均分是 ${avg.toFixed(0)}，${tone}（全盘平均 ${allAvg.toFixed(0)}）。分数是相对刻度，不是绝对值。` },
+      { h: '这些年里最亮和最闷的', t: `${best.length ? `高点：${best.slice(0, 2).join('、')}` : '没有特别高的点'}；${worst.length ? `低点：${worst.slice(0, 2).join('、')}` : '没有特别低的点'}。高点适合推进，低点适合收口。` },
+      { h: '怎么用这条线', t: '它不是命运表，是把「顺/不顺」画成可视的起伏。真正决定走向的，是你在这几步里做了什么。' },
+    ],
+    advice: [
+      '把下一步换运的年龄记下来：换运前后半年，通常是最容易做决定、也最容易冲动的时候。',
+      '低点年别做大额投入，高点年别只观望——这两条比记分数管用。',
+    ],
+    caveat: '线按年岁等距绘制，实际每步大运十年；起点与交运按节气推算，出生时刻未知时按日估算。',
+    footer: '以上是把盘面符号翻译成话，不是断语；真正的判断要看现实里那几步。',
+  };
+}
+
+/**
+ * 生成盘面顶部的人话总结。
+ * @param {object} r compute() 的结果
+ * @returns {null|{system,title,chips,lead,sections,advice,caveat,footer}}
+ */
+function plainSummary(r) {
+  if (!r || typeof r !== 'object') return null;
+  if (r.system === 'bazi') return baziSummary(r);
+  if (r.system === 'ziwei') return ziweiSummary(r);
+  if (r.system === 'liuyao') return liuyaoSummary(r);
+  if (r.system === 'meihua') return meihuaSummary(r);
+  if (r.system === 'daliuren') return daliurenSummary(r);
+  if (r.system === 'qimen') return qimenSummary(r);
+  if (r.system === 'tarot') return tarotSummary(r);
+  if (r.system === 'hepan') return hepanSummary(r);
+  if (r.system === 'trend') return trendSummary(r);
+  return null;
+}
+
+return { plainSummary };
+})();
+
 __mods.index = (function () {
 // 统一入口：解析参数、分派到各体系、生成可读摘要
 const { buildBazi } = (__mods.bazi || {});
@@ -20630,8 +21319,11 @@ function baziText(r) {
     + `　地势 ${p.dishi}　自坐 ${p.zizuo}　空亡 ${p.kongwang.join('')}`
     + (p.shensha && p.shensha.length ? `　神煞 ${p.shensha.join('、')}` : '');
   const wuxing = Object.entries(r.wuxing).map(([k, v]) => `${k}${v}`).join(' ');
+  // 命宫/身宫由「生月 + 生时支」定：时柱未知时它们是 null，不能拼字符串，也不能拿占位值顶上
   const palaces = r.palaces
-    ? `【胎元】${r.palaces.taiyuan.ganzhi}　胎息 ${r.palaces.taixi ? r.palaces.taixi.ganzhi : '—'}　命宫 ${r.palaces.minggong.ganzhi}　身宫 ${r.palaces.shengong.ganzhi}`
+    ? `【胎元】${r.palaces.taiyuan.ganzhi}　胎息 ${r.palaces.taixi ? r.palaces.taixi.ganzhi : '—'}`
+      + (r.palaces.minggong ? `　命宫 ${r.palaces.minggong.ganzhi}` : '　命宫 时柱暂缺，不排')
+      + (r.palaces.shengong ? `　身宫 ${r.palaces.shengong.ganzhi}` : '　身宫 时柱暂缺，不排')
     : '';
   const dayun = r.dayun.list.slice(0, 8)
     .map((d) => `${d.startAge}岁 ${d.ganzhi}(${d.stemTenGod})${d.luck ? `·${d.luck.tier}` : ''}${d.relations && d.relations.length ? `[${d.relations.join('')}]` : ''}`).join('　');
@@ -20671,10 +21363,12 @@ function baziText(r) {
     (r.frame.yongshen.qt ? `　穷通：${r.frame.yongshen.qt.month}${r.frame.yongshen.qt.stem}取${r.frame.yongshen.qt.yong.join('、')}（首取${r.frame.yongshen.qt.primary}）` : ''),
     `十神权重：${Object.entries(r.frame.godStats.groups).map(([k, v]) => `${k}${v}`).join(' ')}`,
   ] : [];
+  const hourMissing = r.hourUnknown === true || !P.hour;
   return [
-    `【四柱】${P.year.ganzhi} ${P.month.ganzhi} ${P.day.ganzhi} ${P.hour.ganzhi}`,
+    `【四柱】${P.year.ganzhi} ${P.month.ganzhi} ${P.day.ganzhi}${P.hour ? ` ${P.hour.ganzhi}` : '（时柱暂缺）'}`,
     `日主：${r.dayMaster.stem}${r.dayMaster.element}（${r.dayMaster.yinYang}）　空亡：${r.kongwang.join('')}`,
-    line('年柱', P.year), line('月柱', P.month), line('日柱', P.day), line('时柱', P.hour),
+    line('年柱', P.year), line('月柱', P.month), line('日柱', P.day),
+    ...(hourMissing ? [] : [line('时柱', P.hour)]),
     `五行：${wuxing}`,
     ...(palaces ? [palaces] : []),
     `日主强弱：${r.strength.level}（${r.strength.score}）　${r.strength.detail}`,
@@ -21268,6 +21962,20 @@ function compute(input = {}) {
     delete args.partner2;
   }
   const r = jsonSafe(computeRaw(args));
+  // 「所问之事」以前只有六爻和塔罗会落到结果里，梅花/六壬/奇门/小六壬都丢掉了：
+  // 于是第一屏想说「你问的是……」却拿不到那句话。这里统一补齐，已有的值不动。
+  if (r && !r.question && typeof args.question === 'string' && args.question.trim()
+    && ['liuyao', 'meihua', 'daliuren', 'qimen', 'tarot', 'xiaoliuren'].includes(r.system)) {
+    r.question = args.question.trim();
+  }
+  // 顶部那段「人话总结」：命盘两类 + 问事五类 + 合盘 + 走势，都由 plainSummary 决定给不给。
+  // 数据不够时它返回 null，不动 r.brief；生成失败只记 briefError，绝不因此拖垮排盘。
+  if (r) {
+    try {
+      const brief = plainSummary(r);
+      if (brief) r.brief = brief;
+    } catch (e) { r.briefError = String((e && e.message) || e); }
+  }
   if (revision) r.revision = revision;
   if (r && r.system === 'bazi') {
     r.classics = classicsFor(r);
@@ -21290,6 +21998,16 @@ function compute(input = {}) {
   if (r && (r.system === 'bazi' || r.system === 'ziwei') && r.input && r.input.longitude == null && r.summary) {
     r.summary = `⚠ 未提供出生地或经度：按东八区平太阳时排盘，时柱可能与本命盘相差一个时辰；海外出生请先把当地时间换算成东八区标准时。\n${r.summary}`;
   }
+  // 时辰未知：固定提示必须在第一行。放在所有警告之后 prepend，才不会被地警告/精度提示挤到第二行
+  if (r && r.system === 'bazi' && r.hourUnknown && r.summary) {
+    r.summary = `时柱按正午暂算，涉及时柱的结论仅供参考
+${r.summary}`;
+  }
+  // 趋势是降级而不是阻断：起运按日估算，也要在首行说清
+  if (r && r.system === 'trend' && r.hourUnknown && r.summary) {
+    r.summary = `时柱暂缺：起运与大运按日估算，仅供参考
+${r.summary}`;
+  }
   // 显式要求时才附加解析模块，避免默认输出过长；「所问之事」与「询问方向」一并传进去
   if (args.withInterpret) {
     r.interpret = interpret(r, {
@@ -21298,7 +22016,10 @@ function compute(input = {}) {
     });
   }
   // 八字 × 紫微交叉验证：同一份出生信息再排另一套盘，并列两边对同一件事的说法
-  if (args.cross === true && (r.system === 'bazi' || r.system === 'ziwei')) {
+  // 交叉验证要再排另一套盘：时辰未知时紫微排不出来，这条支路直接跳过，
+  // 不能拿正午排一张紫微盘来「交叉」，那是两张都不可信的盘互证。
+  if (args.cross === true && args.hourUnknown === true) r.crossSkipped = 'HOUR_UNKNOWN';
+  if (args.cross === true && args.hourUnknown !== true && (r.system === 'bazi' || r.system === 'ziwei')) {
     const cdt = parseDateTime(args.datetime);
     const common = {
       ...cdt,
@@ -21532,10 +22253,16 @@ function computeRaw(args = {}) {
       dst: args.dst !== false,
       // 流年表默认从「今年」起排；要复现历史结论就把基准年钉死
       nowYear: asOf ? asOf.year : undefined,
+      // 时辰未知：三柱模式（时柱不排、精度降到日、摘要首行固定提示）
+      hourUnknown: args.hourUnknown === true,
     });
     return { ...result, ...(asOf ? { asOf } : {}), precision: dt.precision, summary: baziText(result) };
   }
   if (system === 'ziwei') {
+    // 命宫由「生月 + 生时支」定：时支未知则整盘无处落脚，没有「大概的紫微盘」这种东西
+    if (args.hourUnknown === true) {
+      throw fail('HOUR_UNKNOWN', '紫微必须有出生时刻：命宫由生月与生时支定，时支未知则整盘不成立。请补上出生时刻，或改用八字三柱模式只看年/月/日。');
+    }
     const dt = parseDateTime(args.datetime);
     const asOf = checkAsOf(args.asOf);
     const result = buildZiwei({
@@ -21592,6 +22319,10 @@ function computeRaw(args = {}) {
     return { ...result, summary: qimenText(result) };
   }
   if (system === 'hepan') {
+    // 双方夫妻宫、大运都依赖时支：任一方时辰未知就不出盘，免得「差不多」的合盘误导决定
+    if (args.hourUnknown === true || (args.partner && args.partner.hourUnknown === true)) {
+      throw fail('HOUR_UNKNOWN', '合盘需要双方都有出生时刻：夫妻宫与大运都依赖时支。请补齐时刻后再看，或用八字三柱模式各自看年/月/日。');
+    }
     const partner = args.partner;
     if (!partner || typeof partner !== 'object') {
       throw fail('E_PARTNER', '合盘需要 partner：{ datetime, gender, address? }，其中 partner.datetime 是对方的公历出生时间');
@@ -21804,8 +22535,12 @@ function computeRaw(args = {}) {
   }
   if (system === 'trend') {
     const dt = parseDateTime(args.datetime);
+    // 「现在在第几步」要有个当前年份；引擎不读挂钟，只认 asOf。
+    // 不给 asOf 就不标当前位置（summary 会少一句，但结果可复现）。
+    const nowParts = args.asOf ? checkAsOf(args.asOf) : undefined;
     const result = buildTrend({
       ...dt,
+      nowYear: nowParts ? nowParts.year : undefined,
       gender: requireGender(args.gender),
       toAge: args.toAge,
       lateZi: args.lateZi !== false,
@@ -21814,8 +22549,15 @@ function computeRaw(args = {}) {
       longitude: typeof args.longitude === 'number' ? args.longitude : undefined,
       address: typeof args.address === 'string' ? args.address : undefined,
       geo: args.geo && typeof args.geo === 'object' ? args.geo : undefined,
+      hourUnknown: args.hourUnknown === true,
     });
-    return { ...result, precision: dt.precision, summary: trendText(result) };
+    // 趋势没有独立的 dayun 字段（大运在 buildTrend 内部用），所以精度标记挂在结果顶层
+    return {
+      ...result,
+      ...(args.hourUnknown === true ? { hourUnknown: true, hourPrecision: 'day' } : {}),
+      precision: dt.precision,
+      summary: trendText(result),
+    };
   }
   if (system === 'fengshui') {
     const action = args.action === 'advise' ? 'advise' : args.action === 'xuankong' ? 'xuankong' : 'natal';
@@ -22163,7 +22905,16 @@ function nameText(r) {
 /** 给模型的紧凑文本（去掉大字段，保留摘要；带解析时附上解析） */
 function renderText(result) {
   const base = result.summary ?? JSON.stringify(result, null, 2);
-  const parts = [base];
+  // 先给一段人话，再给盘面细节：模型照这段复述，就不至于一开口就是术语表
+  const NL = String.fromCharCode(10);
+  const brief = result.brief
+    ? ['【先说结论】' + result.brief.lead]
+      .concat((result.brief.sections || []).map((x) => ['　', x.h, '：', x.t].join('')))
+      .concat((result.brief.advice || []).length ? ['　可以试着做的：' + result.brief.advice.map((a) => String(a).replace(/。$/, '')).join('；') + '。'] : [])
+      .concat(result.brief.caveat ? ['　※ ' + result.brief.caveat] : [])
+      .join(NL) + NL
+    : '';
+  const parts = [brief + base];
   if (result.shadow && result.shadow.id) {
     const s = result.shadow;
     parts.push(`【影子盘】${s.id}（同参数同 ID；版本 ${s.version}）`
@@ -22240,6 +22991,7 @@ function renderText(result) {
 // 问事解读提示：把一张盘打包成「先答他所问、不堆术语、回到现实核对」的提示，供面板一键复制
 // （本仓 esbuild 不接受 `export {} from`，先静态 import 再 export）
 const { buildEventPrompt, ASK_KINDS } = (__mods['event-prompt'] || {});
+const { plainSummary } = (__mods['plain-summary'] || {});
 
 
 
@@ -22255,7 +23007,7 @@ return { interpret, DIRECTIONS, DIRECTION_DEFAULT, BRIGHTNESS, flowOf, geocodeAd
 })();
 
 window.Engine = __mods.index;
-window.__MP_VER = "0.59.0";
+window.__MP_VER = "0.59.1";
 </script>
 <script>
 // 两个 UI 共用的表单规则：宿主面板（src/app.js）与独立页（src/web-ui.js）。
@@ -22348,7 +23100,18 @@ window.__MP_VER = "0.59.0";
     return Number.isFinite(n) ? n : null;
   }
 
-  window.__MPCore = { NEED_ASK, needAsk, parseLines, toNumber, parseRGB, hexToRGB, luminance, contrastRatio, pickOnColor, ON_DARK, ON_LIGHT, kindOfDirection };
+  /**
+   * 本机今天的日期（YYYY-MM-DD）。
+   * 只给「现在走到第几步」这类需要当前位置的展示用：引擎不读挂钟，
+   * 当前时间一律由界面以 asOf 传入，这样同一条线任何时候重新生成都一字不差。
+   */
+  function todayStamp(date) {
+    const d = date instanceof Date ? date : new Date();
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+  }
+
+  window.__MPCore = { NEED_ASK, needAsk, parseLines, toNumber, parseRGB, hexToRGB, luminance, contrastRatio, pickOnColor, ON_DARK, ON_LIGHT, kindOfDirection, todayStamp };
 })();
 
 </script>
@@ -22872,6 +23635,25 @@ window.__MP_VER = "0.59.0";
 .mp-askcopy{border:1px solid var(--red);background:transparent;color:var(--red);font:inherit;font-size:12px;padding:4px 11px;border-radius:999px;cursor:pointer;transition:background .14s,color .14s}
 .mp-askcopy:hover{background:var(--red);color:var(--on-accent)}
 .mp-askcopy-hint{color:var(--muted);font-size:11.5px}
+/* 三柱盘提示：表下一行，别让人以为漏画了一列 */
+.pp-warn{margin:8px 0 0;padding:7px 10px;border:1px solid color-mix(in srgb,var(--quan) 34%,var(--line));border-radius:8px;background:color-mix(in srgb,var(--quan) 10%,transparent);color:var(--ink2);font-size:11.5px;line-height:1.55}
+/* 顶部人话总结：第一屏唯一的「先说结论」块，边框与留白都比盘面重一档 */
+.mp-br{margin:0 0 12px;padding:14px 16px 12px;border:1px solid color-mix(in srgb,var(--red) 26%,var(--line));border-radius:12px;
+  background:linear-gradient(180deg,color-mix(in srgb,var(--red) 6%,var(--card)),var(--card));color:var(--ink)}
+.mp-br-h{display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-bottom:6px}
+.mp-br-h>b{font-size:13.5px;letter-spacing:.04em;color:var(--red)}
+.mp-br-chips{display:flex;gap:5px;flex-wrap:wrap;margin-left:auto}
+.mp-br-chips span{font-size:11px;padding:1px 7px;border-radius:999px;background:var(--band);border:1px solid var(--hair);color:var(--label)}
+.mp-br-lead{margin:0 0 10px;font-size:13.5px;line-height:1.75;color:var(--ink)}
+.mp-br-sec{margin:9px 0 0;padding-top:8px;border-top:1px dashed var(--hair)}
+.mp-br-sec b{display:block;font-size:12.5px;color:var(--ink2);margin-bottom:3px}
+.mp-br-sec p{margin:0;font-size:12.5px;line-height:1.75;color:var(--ink2)}
+.mp-br-adv{margin:10px 0 0;padding-top:8px;border-top:1px dashed var(--hair)}
+.mp-br-adv b{display:block;font-size:12.5px;color:var(--ink2);margin-bottom:4px}
+.mp-br-adv ul{margin:0;padding-left:17px;font-size:12.5px;line-height:1.7;color:var(--ink2)}
+.mp-br-adv li{margin:2px 0}
+.mp-br-cav{margin:10px 0 0;padding:7px 9px;border-radius:8px;background:color-mix(in srgb,var(--quan) 12%,transparent);color:var(--ink2);font-size:11.5px;line-height:1.6}
+.mp-br-foot{margin:8px 0 0;color:var(--muted);font-size:11px}
 /* 能力边界：与名词解释同款轻量折叠，但每条要能读到「为什么不答」 */
 .mp-it-limits{margin:0 16px 12px;font-size:12px;line-height:1.85;color:var(--muted);border-top:1px dashed var(--line);padding-top:8px}
 .mp-it-limits summary{cursor:pointer;font-family:system-ui,sans-serif;letter-spacing:.06em;color:var(--label);margin-bottom:6px}
@@ -23887,7 +24669,7 @@ window.__MP_VER = "0.59.0";
       </div>`;
     })() : '';
     pp._zw = r; // 详情面板用：点击宫位时从这里取完整宫数据
-    return `<div class="pp">
+    return pp.briefHTML(r) + `<div class="pp">
       <input type="radio" name="ppm" id="ppm-ben" class="pp-r" checked>
       <input type="radio" name="ppm" id="ppm-da" class="pp-r">
       <input type="radio" name="ppm" id="ppm-ln" class="pp-r">
@@ -24127,7 +24909,7 @@ window.__MP_VER = "0.59.0";
         return `<span class="pp-chip ${cls}">${esc(l)}</span>`;
       }).join('')}</div>`
       : '';
-    return `<div class="pp" style="padding:14px">
+    return pp.briefHTML(r) + `<div class="pp" style="padding:14px">
       <div class="mp-mh-head">起卦 ${r.cast.notation.join('、')}（自下而上）　日辰 ${r.dayGanZhi.name}</div>
       <div class="mp-hy-wrap">${ben}${bian}</div>
       ${bodyRow}
@@ -24178,7 +24960,7 @@ window.__MP_VER = "0.59.0";
 
     const cuoTri = TRI_OF(r.cuo.name) || ['', ''];
     const zongTri = TRI_OF(r.zong.name) || ['', ''];
-    return `<div class="pp mp-mh">
+    return pp.briefHTML(r) + `<div class="pp mp-mh">
       <div class="mp-mh-main">
         ${mainBox}
         ${mini('互卦', r.hu.name, r.hu.upper, r.hu.lower, '中藏之象')}
@@ -24246,7 +25028,7 @@ window.__MP_VER = "0.59.0";
       <div class="dl-t3">${sc.chu.zhi} → ${sc.zhong.zhi} → ${sc.mo.zhi}</div>
       <div class="dl-t2">节气 ${r.jieqi.name}${r.jieqi.time ? ' ' + r.jieqi.time : ''}</div>
     </div>`;
-    return `<div class="pp mp-dl">
+    return pp.briefHTML(r) + `<div class="pp mp-dl">
       <div class="mp-dl-head">日 ${r.dayGanZhi}　时 ${r.hourZhi}（${r.dayNight}贵）　月将 ${r.yueJiang.name}${r.yueJiang.zhi}　节气 ${r.jieqi.name}　贵人${r.guiren.reverse ? '逆' : '顺'}行</div>
       <div class="mp-dl-sc">${cbox(sc.chu, '初传')}${cbox(sc.zhong, '中传')}${cbox(sc.mo, '末传')}${ge}</div>
       <div class="mp-dl-sk">${keCells}</div>
@@ -24270,7 +25052,7 @@ window.__MP_VER = "0.59.0";
     const q = r.question ? esc(r.question) : '<span class="pp-dim">（未填写，可在上方输入后重抽）</span>';
     // 解读段落里会回显用户问题（"你问的是「…」"），同样走转义
     const reading = (r.reading || []).map((p) => `<p>${esc(p)}</p>`).join('');
-    return `<div class="pp mp-tt">
+    return pp.briefHTML(r) + `<div class="pp mp-tt">
       <div class="mp-tt-q"><b>所问</b>${q}</div>
       <div class="mp-tt-head">${r.spread}${r.castAt ? `　·　抽牌于 ${r.castAt}` : ''}</div>
       <div class="mp-tt-grid">${cards}</div>
@@ -24321,7 +25103,7 @@ window.__MP_VER = "0.59.0";
       <div class="mp-hp-dimh"><span>${d.label}</span><b class="${d.score >= 10 ? 'good' : d.score < 0 ? 'bad' : ''}">${d.score >= 0 ? '+' : ''}${d.score}</b></div>
       <div class="mp-hp-dimt">${d.text}</div>
     </div>`).join('');
-    return `<div class="pp mp-hp">
+    return pp.briefHTML(r) + `<div class="pp mp-hp">
       <div class="mp-hp-head"><b>${r.score.level}</b><span>${r.score.total}/100</span></div>
       <div class="mp-hp-sides">${side(r.a, '你')}${side(r.b, '对方')}</div>
       <div class="mp-hp-dims">${dims}</div>
@@ -24405,7 +25187,7 @@ window.__MP_VER = "0.59.0";
         <div class="pp-qm-bot"><span class="dim">${p.ganYing ? esc(`${p.ganYing.tian}加${p.ganYing.di} ${p.ganYing.name}`) : ''}</span></div>
       </div>`;
     };
-    return `<div class="pp mp-qm">
+    return pp.briefHTML(r) + `<div class="pp mp-qm">
       <div class="mp-qm-head">
         <b>${r.ju}</b>
         <span>${r.siZhu.year} ${r.siZhu.month} ${r.siZhu.day} ${r.siZhu.time}</span>
@@ -24435,7 +25217,7 @@ window.__MP_VER = "0.59.0";
     </div>`).join('');
     const list = (who) => (r.interactions || []).filter((h) => h.who === who)
       .map((h) => `<li><b class="m-${h.mutagen}">${h.mutagen}</b>${h.star}：本命${h.ownPalace} → 对方${h.landingPalace || '盘外'}${h.strong ? '<i>（强）</i>' : ''}</li>`).join('');
-    return `<div class="pp mp-hp">
+    return pp.briefHTML(r) + `<div class="pp mp-hp">
       <div class="mp-hp-head"><b>${r.score.level}</b><span>${r.score.total}/100　紫微合盘</span></div>
       <div class="mp-hp-sides">${side(r.a, '你')}${side(r.b, '对方')}</div>
       <div class="mp-hp-dims">${dims}</div>
@@ -24575,7 +25357,6 @@ window.__MP_VER = "0.59.0";
    * 与 curveHTML 的分工：curveHTML 是八字里的「大运阶梯 + 流年折线」；这张是同一批
    * 评分的 K 线形态，单独成块可直接截图，也嵌在八字结果底部。
    */
-  let klineSeq = 0;
   pp.trendChart = function (r) {
     const pts = r && Array.isArray(r.points) ? r.points : [];
     if (pts.length < 2) return '';
@@ -24592,7 +25373,20 @@ window.__MP_VER = "0.59.0";
     const sc = (p) => num(p.score);
     const yb = M.t + ph;
     const stripTop = yb + 20, stripH = 22;
-    const clipId = `klclip${(klineSeq += 1)}`;
+    // clipPath 的 id 要唯一，但**不能靠全局自增**：自增会让同一张盘两次渲染出不同的 id，
+    // 截图对拍、快照测试永远对不上，同一页重复渲染也在无谓地制造新 id。
+    // 改成盘面内容的短哈希——不同盘不同 id，同一张盘永远同一个 id。
+    const clipKey = (() => {
+      let h = 2166136261;
+      const feed = (v) => {
+        const t = String(v == null ? '' : v);
+        for (let i = 0; i < t.length; i++) { h ^= t.charCodeAt(i); h = Math.imul(h, 16777619); }
+      };
+      feed(n); feed(pts[0] && pts[0].age); feed(pts[n - 1] && pts[n - 1].age);
+      for (const p of pts) feed(p && p.score);
+      return (h >>> 0).toString(36);
+    })();
+    const clipId = `klclip${clipKey}`;
 
     // 大运交替底色 + 分界虚线 + 底部段名条（段名放条纹里，避开顶部高低岁标记）
     const bands = segs.map((s, i) => {
@@ -24706,9 +25500,15 @@ window.__MP_VER = "0.59.0";
       </svg>${legend}</div>`;
   };
 
-  /** 人生 K 线整块：图 + 大运分段 + 高低年份 + 口径说明；数据不足时退回文字摘要 */
-  pp.trendHTML = function (r) {
+  /**
+   * 人生 K 线整块：图 + 大运分段 + 高低年份 + 口径说明；数据不足时退回文字摘要。
+   * @param {object} r trend 结果
+   * @param {{brief?:boolean}} [opt] 嵌在八字页里时传 brief:false——
+   *   那一页最上面已经有八字本人话，再叠一个「先说结论」会变成两个方框抢第一屏。
+   */
+  pp.trendHTML = function (r, opt) {
     if (!r) return '';
+    const withBrief = !(opt && opt.brief === false);
     const chart = pp.trendChart(r);
     if (!chart) return pp.quickHTML(r);
     const segs = Array.isArray(r.segments) ? r.segments : [];
@@ -24738,7 +25538,7 @@ window.__MP_VER = "0.59.0";
     }
     statCells.push(`<span><em>波动幅度</em><b>${span.toFixed(0)}</b></span>`);
     const stats = `<div class="kl-stats">${statCells.join('')}</div>`;
-    return `<section class="mp-kline" aria-label="人生K线结果">
+    return (withBrief ? pp.briefHTML(r) : '') + `<section class="mp-kline" aria-label="人生K线结果">
       <div class="mp-kline-h"><b>人生 K 线</b><span>${esc(meta.birth || '')}　日主 ${esc(meta.dayMaster || '')}　${esc(st.level || '')}${st.score ? `（${st.score}）` : ''}</span></div>
       ${chart}
       ${stats}
@@ -24843,8 +25643,40 @@ window.__MP_VER = "0.59.0";
     </section>`;
   };
 
+  /**
+   * 盘面顶部的人话总结（engine/plain-summary.js 的结果 → 一个方框）。
+   * 位置固定在最前：先给结论，再用下面的盘面作依据——反过来大多数人读不到第二屏。
+   *
+   * 命盘两类、问事五类、合盘与走势都走这一个入口：没有 brief（数据不够）就返回空串，
+   * 绝不让一块空方框留在页面上。各盘渲染时只写 pp.briefHTML(r)，不再各自判一次。
+   */
+  pp.briefHTML = function (r) {
+    return r && r.brief ? pp.summaryHTML(r.brief) : '';
+  };
+
+  pp.summaryHTML = function (b) {
+    if (!b || !b.lead) return '';
+    const secs = (b.sections || []).map((x) => `<div class="mp-br-sec"><b>${esc(x.h)}</b><p>${esc(x.t)}</p></div>`).join('');
+    const adv = (b.advice && b.advice.length)
+      ? `<div class="mp-br-adv"><b>可以试着做的</b><ul>${b.advice.map((a) => `<li>${esc(a)}</li>`).join('')}</ul></div>`
+      : '';
+    const chips = (b.chips && b.chips.length)
+      ? `<div class="mp-br-chips">${b.chips.map((c) => `<span>${esc(c)}</span>`).join('')}</div>`
+      : '';
+    return `<section class="mp-br" aria-label="先说结论">
+      <div class="mp-br-h"><b>${esc(b.title || '先看这一张')}</b>${chips}</div>
+      <p class="mp-br-lead">${esc(b.lead)}</p>
+      ${secs}
+      ${adv}
+      ${b.caveat ? `<p class="mp-br-cav">※ ${esc(b.caveat)}</p>` : ''}
+      ${b.footer ? `<p class="mp-br-foot">${esc(b.footer)}</p>` : ''}
+    </section>`;
+  };
+
   pp.baziHTML = function (r) {
-    const cols = [['year', '年柱'], ['month', '月柱'], ['day', '日柱'], ['hour', '时柱']];
+    // 时辰未知时 pillars.hour 为 null：只画存在的柱，不能拿 null 去取 .stemTenGod
+    const cols = [['year', '年柱'], ['month', '月柱'], ['day', '日柱'], ['hour', '时柱']]
+      .filter(([k]) => r.pillars[k]);
     const SHORT = { year: '年', month: '月', day: '日', hour: '时' };
     const ELC = { 木: 'wood', 火: 'fire', 土: 'earth', 金: 'metal', 水: 'water' };
     // 十神按五类分组上色：比劫 / 食伤 / 财 / 官杀 / 印。低饱和，避免抢干支五行主色
@@ -24872,7 +25704,7 @@ window.__MP_VER = "0.59.0";
       : GEN[seasonEl] === e ? '相'
         : GEN[e] === seasonEl ? '休'
           : OVR[e] === seasonEl ? '囚' : '死');
-    const wxRow = `<tr><td class="bz-lbl">五行</td><td class="bz-wxs" colspan="4">${
+    const wxRow = `<tr><td class="bz-lbl">五行</td><td class="bz-wxs" colspan="${cols.length}">${
       ['旺', '相', '休', '囚', '死'].map((st) => {
         const e = WX_ALL.find((x) => stateOf(x) === st) || seasonEl;
         return `<i><b class="wx-${ELC[e]}">${e}</b><em>${st}</em></i>`;
@@ -24973,8 +25805,9 @@ window.__MP_VER = "0.59.0";
         ${ssGroups.map((g) => `<div class="pp-ssg"><span class="ssg-gt">${g.cat}</span><span class="ssg-gi">${g.items.map((i) => `<span class="pp-ssi ${i.luck || 'neutral'}" title="${esc(`${i.via}查${i.target} ｜ ${i.rule}`)}">${i.name}<em>${i.pillars.map((k) => SHORT[k] || '').join('')}</em></span>`).join('')}</span></div>`).join('')}
         <div class="ssx-h" style="border-top:none;padding-top:4px;margin-top:4px">神煞只作参考，吉凶仍须看格局、旺衰与行运。</div>
       </div>` : '';
-    return `<div class="pp" style="padding:12px">
+    return pp.briefHTML(r) + `<div class="pp" style="padding:12px">
       <table class="pp-bz">${head}<tbody>${rows}</tbody></table>
+      ${r.hourUnknown ? `<div class="pp-warn" role="note">时柱暂缺：只排年/月/日三柱，起运与交运按日估算。时柱按正午暂算，涉及时柱的结论仅供参考。</div>` : ''}
       <div class="pp-rel"><div><b>天干</b>${(r.relations && r.relations.stems.length) ? r.relations.stems.join(' · ') : '—'}</div>
       <div><b>地支</b>${(r.relations && r.relations.branches.length) ? r.relations.branches.join(' · ') : '—'}</div></div>
       ${str}
@@ -24995,8 +25828,9 @@ window.__MP_VER = "0.59.0";
       ${r.palaces ? sect('胎命身', `<div class="pp-chips">
         <span class="pp-chip" title="${esc(r.palaces.taiyuan.note)}">胎元 ${esc(r.palaces.taiyuan.ganzhi)}</span>
         ${r.palaces.taixi ? `<span class="pp-chip" title="${esc(r.palaces.taixi.note)}">胎息 ${esc(r.palaces.taixi.ganzhi)}</span>` : ''}
-        <span class="pp-chip" title="${esc(r.palaces.minggong.note)}">命宫 ${esc(r.palaces.minggong.ganzhi)}</span>
-        <span class="pp-chip" title="${esc(r.palaces.shengong.note)}">身宫 ${esc(r.palaces.shengong.ganzhi)}</span>
+        ${r.palaces.minggong ? `<span class="pp-chip" title="${esc(r.palaces.minggong.note)}">命宫 ${esc(r.palaces.minggong.ganzhi)}</span>` : ''}
+        ${r.palaces.shengong ? `<span class="pp-chip" title="${esc(r.palaces.shengong.note)}">身宫 ${esc(r.palaces.shengong.ganzhi)}</span>` : ''}
+        ${(!r.palaces.minggong || !r.palaces.shengong) ? '<span class="pp-chip" title="命宫与身宫由生月与生时支合数定宫；时柱暂缺，这两宫不排">命宫·身宫 时柱暂缺不排</span>' : ''}
       </div>`) : ''}
       ${ssx}
       <div style="margin-top:8px;font-size:12px;color:var(--muted)">上一节 ${r.jieqi.previous.name} ${r.jieqi.previous.time}　下一节 ${r.jieqi.next.name} ${r.jieqi.next.time}　${r.dayun.rule}，${r.dayun.startAge.years}岁起运${(r.dayun.jiao && r.dayun.jiao.at) ? `（交运 ${r.dayun.jiao.at}，${r.dayun.jiao.frame}）` : ''}</div>
@@ -26318,7 +27152,9 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
   async function run() {
     const runStart = mpNow();
     const date = el('date').value;
-    const time = el('time').value;
+    // 勾了「时辰未知」就不读钟点：读出来的只是占位值，用它排出来的时柱是编的
+    const hourUnknown = !!(el('hourunknown') && el('hourunknown').checked) && (tab === 'bazi' || tab === 'trend');
+    const time = hourUnknown ? '12:00' : el('time').value;
     let lineWarn = '';
     const timed = kindOf(tab) === 'cast' && usesTimeInput();
     // 所问之事必填：不给一份没有落点的解读
@@ -26338,6 +27174,7 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
     if (tab === 'bazi' || tab === 'ziwei' || tab === 'hepan') {
       // 合盘主方同样要性别与出生地：引擎里合盘的性别是必填，地址决定真太阳时
       args.gender = el('gender').value;
+      if (hourUnknown) args.hourUnknown = true;
       if (el('latezi')) args.lateZi = el('latezi').checked;
       args.trueSolar = el('ts').checked;
       const addr = el('addr').value.trim();
@@ -26433,6 +27270,7 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
       const nums = mbAnswersForEngine();
       if (nums.length) args.answers = nums;
     }
+    if (tab === 'trend' && hourUnknown) args.hourUnknown = true;
     if (tab === 'trend') { args.gender = el('gender').value; args.toAge = Number(el('toage').value) || 60; args.trueSolar = el('ts').checked; args.lateZi = el('latezi') ? el('latezi').checked : true; }
     if (tab === 'fengshui') {
       args.action = fsMode;
@@ -26472,6 +27310,8 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
     if (tab === 'qimen') args.direction = el('qdir').value;
     try {
       const computeStart = mpNow();
+      // 同面板：当前日期由界面给，引擎不读挂钟（保证同一条线可复现）
+      if (tab === 'trend' && !args.asOf && Core.todayStamp) args.asOf = Core.todayStamp();
       const r = window.Engine.compute(args);
       const computeMs = mpNow() - computeStart;
       // 影子盘：先与本地上一张同 baseId 的盘比对，再存档；失败不影响主结果
@@ -26484,6 +27324,7 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
           trend = window.Engine.compute({
             system: 'trend', datetime: `${date}T${time}`, gender: args.gender, toAge: 100,
             trueSolar: args.trueSolar, lateZi: args.lateZi !== false,
+            ...(Core.todayStamp ? { asOf: args.asOf || Core.todayStamp() } : {}),
             ...(args.address ? { address: args.address } : {}),
             ...(typeof args.longitude === 'number' ? { longitude: args.longitude } : {}),
             ...(args.geo ? { geo: args.geo } : {}),
@@ -26496,7 +27337,7 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
         try { caliber = window.Engine.caliberCompare(args); } catch (e) { caliber = null; }
       }
       const html = (lineWarn ? `<div class="note">${lineWarn}</div>` : '') + (tab === 'ziwei' ? window.__PP.ziweiHTML(r)
-        : tab === 'bazi' ? (window.__PP.baziHTML(r) + (trend ? window.__PP.trendHTML(trend) : ''))
+        : tab === 'bazi' ? (window.__PP.baziHTML(r) + (trend ? window.__PP.trendHTML(trend, { brief: false }) : ''))
           : tab === 'hepan' ? (r.chart === 'ziwei' ? window.__PP.ziweiHepanHTML(r) : window.__PP.hepanHTML(r))
             : tab === 'qimen' ? (window.__PP.qimenHTML(r) + window.__PP.qimenFactsHTML(r))
               : tab === 'meihua' ? window.__PP.meihuaHTML(r)
@@ -26635,7 +27476,16 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
     // 梅花「数字起卦」不参与时间计算，日期/时刻在此模式下隐藏，避免误导；人格问卷同样与日期无关
     const showDT = tab !== 'tarot' && tab !== 'mbti' && !mhNum;
     el('for-date').style.display = showDT ? '' : 'none';
-    el('for-time').style.display = showDT && kindOf(tab) !== 'date' ? '' : 'none';
+    // 「时辰未知」只对八字与人生K线开放：紫微/合盘没有时支就没有盘，不提供这个勾选
+    const canUnknown = tab === 'bazi' || tab === 'trend';
+    const hu = el('hourunknown');
+    if (hu) {
+      const box = el('for-hourunknown');
+      if (box) box.style.display = showDT && canUnknown ? '' : 'none';
+      if (!canUnknown && hu.checked) hu.checked = false;
+    }
+    const hideTime = showDT && kindOf(tab) !== 'date' && !(canUnknown && hu && hu.checked);
+    el('for-time').style.display = hideTime ? '' : 'none';
   }
 
   /** 速查类子表单：择日/小六壬/人生K/风水/起名各自的小块与分段按钮 */
@@ -27011,6 +27861,8 @@ document.head.appendChild(Object.assign(document.createElement('style'), { textC
     // C3 深链：带 #mp= 打开时先还原那张盘；没有就照旧是默认示例盘
     const deep = readDeepLink();
     setTab(deep ? deep.tab : 'ziwei');
+  // 勾「时辰未知」当场收起时刻框：不让人以为还要填个点
+  if (el('hourunknown')) el('hourunknown').addEventListener('change', syncMhMode);
     if (deep) fillDeepForm(deep.form);
     Promise.resolve(run()).then(() => { if (deep) deepNote(deep); });
   });