dsh-metaphysics 0.56.0 → 0.57.0

package/engine/geju.js

@@ -303,6 +303,8 @@ function specialPatterns(pillars, dayStem, monthBranch, strength, wuxing, gods)
 // 用神与忌神两行在局中都真有分量、且相克时，五行里恰有一行能接上——克方所生、且能生被克方。
 // 只报这一行在局中的分量，不判「关通了就吉」。
 const TONGGUAN_MIN = 1.5;
+/** 忌神在全局不足这个分量时，展示层降为「中性偏忌」（仍留在 avoid 里参与行运评分） */
+const NEUTRAL_MAX = 0.5;
 export function tongguanOf(favor = [], avoid = [], wuxing = {}) {
   const w = (el) => Math.round((Number(wuxing[el]) || 0) * 10) / 10;
   for (const use of favor) {
@@ -378,6 +380,14 @@ function yongshenOf(dayStem, monthBranch, strength, wuxing, branches = []) {
   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)]}）`;
@@ -387,6 +397,9 @@ function yongshenOf(dayStem, monthBranch, strength, wuxing, branches = []) {
   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) ? '（有争议）' : ''}` : '，气候平和'}。`,
@@ -410,11 +423,14 @@ function yongshenOf(dayStem, monthBranch, strength, wuxing, branches = []) {
     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,

package/engine/handle.js

@@ -0,0 +1,192 @@
+// C1 排盘句柄：把「排这张盘用的参数」压成一段自包含的短字符串。
+//
+// 为什么要自包含而不用内存缓存：工具每次调用可能落在不同进程里（宿主一次工具调用
+// 一个进程），内存里的句柄拿到下一次就失效。这里把参数本身编码进句柄，
+// 任何进程、任何会话都能还原——代价是句柄里带着输入，所以它是编码，不是加密。
+//
+// 用法：
+//   const r = compute({ system: 'bazi', datetime: '1996-01-19T07:31', gender: 'male', address: '安徽池州' });
+//   r.handle                       // 'mc1.eyJ... .a1b2c3d4'
+//   compute({ handle: r.handle, asOf: 2030 })   // 只传增量，参数自动并回去
+//
+// 约定：
+//   * 只收「影响盘面」的参数；trace / shadow / withInterpret / ask 这类输出开关不进句柄，
+//     所以同一张盘无论要不要解析、要不要推导链，句柄都一样；
+//   * 带校验位：句柄被截断或改了字符会报 E_HANDLE，而不是静默排成另一张盘；
+//   * 键序固定，参数写法不同（例如先 system 后 datetime）也得到同一个句柄。
+import { fail } from './fail.js';
+
+const PREFIX = 'mc1.';
+
+/**
+ * 不进句柄的参数：它们只改输出形态或只对某一次追问有效，不影响盘面。
+ * 反过来，seed / asOf / direction / 各流派开关都必须留下——少了它们就复现不出同一张盘。
+ */
+const SKIP = new Set([
+  'handle', 'trace', 'shadow', 'shadowVersion', 'diff', 'withInterpret', 'cross',
+  'verifyPast', 'rectify', 'events', 'ask', 'followup', 'question', 'geocode', 'caliber',
+  // 一句话改参是把原话翻成补丁：补丁已经落在其余参数里，原话本身不进句柄，
+  // 否则同一张盘换个说法就换一个句柄，回放时还会再套一遍补丁。
+  'revise',
+]);
+
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+/** 稳定序列化：对象键排序，数组按原序；只收 JSON 能表达的值 */
+function stable(v) {
+  if (Array.isArray(v)) return `[${v.map((x) => stable(x === undefined ? null : x)).join(',')}]`;
+  if (isObject(v)) {
+    const keys = Object.keys(v).filter((k) => v[k] !== undefined).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stable(v[k])}`).join(',')}}`;
+  }
+  const s = JSON.stringify(v === undefined ? null : v);
+  return s === undefined ? 'null' : s;
+}
+
+/** FNV-1a 32 位：足够挡手误改字与截断，不承担抗篡改 */
+function checksum(text) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, '0');
+}
+
+// base64url 与 UTF-8 都自己实现：引擎要同时在 Node、浏览器与 vm 沙箱里跑，
+// 不能依赖 Buffer，也不能假设宿主有 btoa / TextEncoder。
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+function utf8Bytes(str) {
+  const out = [];
+  for (const ch of String(str)) {
+    let cp = ch.codePointAt(0);
+    if (cp < 0x80) out.push(cp);
+    else if (cp < 0x800) out.push(0xc0 | (cp >> 6), 0x80 | (cp & 63));
+    else if (cp < 0x10000) out.push(0xe0 | (cp >> 12), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
+    else out.push(0xf0 | (cp >> 18), 0x80 | ((cp >> 12) & 63), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
+  }
+  return out;
+}
+
+function utf8String(bytes) {
+  let out = '';
+  for (let i = 0; i < bytes.length;) {
+    const b = bytes[i];
+    let cp;
+    let n;
+    if (b < 0x80) { cp = b; n = 1; }
+    else if (b < 0xe0) { cp = b & 31; n = 2; }
+    else if (b < 0xf0) { cp = b & 15; n = 3; }
+    else { cp = b & 7; n = 4; }
+    for (let k = 1; k < n; k++) cp = (cp << 6) | (bytes[i + k] & 63);
+    i += n;
+    out += String.fromCodePoint(cp);
+  }
+  return out;
+}
+
+function b64url(str) {
+  const bytes = utf8Bytes(str);
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+    out += B64[a >> 2];
+    out += B64[((a & 3) << 4) | ((b === undefined ? 0 : b) >> 4)];
+    if (b === undefined) break;
+    out += B64[((b & 15) << 2) | ((c === undefined ? 0 : c) >> 6)];
+    if (c === undefined) break;
+    out += B64[c & 63];
+  }
+  return out;
+}
+
+function unb64url(s) {
+  const bytes = [];
+  let buf = 0;
+  let bits = 0;
+  for (const ch of s) {
+    const v = B64.indexOf(ch);
+    if (v < 0) throw new Error(`不是 base64url 字符：${ch}`);
+    buf = (buf << 6) | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push((buf >> bits) & 0xff);
+    }
+  }
+  return utf8String(bytes);
+}
+
+/** 从参数里挑出要进句柄的那部分 */
+export function handlePayload(args = {}) {
+  const out = {};
+  for (const [k, v] of Object.entries(args || {})) {
+    if (SKIP.has(k) || v === undefined) continue;
+    out[k] = v;
+  }
+  return out;
+}
+
+/**
+ * 参数 → 句柄。参数里没有可编码内容时返回 ''（例如只传了 { trace: true }）。
+ * @returns {string}
+ */
+export function encodeHandle(args = {}) {
+  const payload = handlePayload(args);
+  if (!Object.keys(payload).length) return '';
+  const body = b64url(stable(payload));
+  return `${PREFIX}${body}.${checksum(body)}`;
+}
+
+/**
+ * 句柄 → 参数。任何不合法都抛 E_HANDLE，并在文案里说清是哪一步不对。
+ * @returns {object}
+ */
+export function decodeHandle(handle) {
+  if (typeof handle !== 'string' || !handle.trim()) {
+    throw fail('E_HANDLE', 'handle 必须是非空字符串；没拿到句柄时照常传 system + datetime 等原始参数即可');
+  }
+  const s = handle.trim();
+  if (!s.startsWith(PREFIX)) {
+    throw fail('E_HANDLE', `handle 前缀不对（应以 ${PREFIX} 开头）：句柄来自旧版本或复制不全，重新排一次盘取新的 handle`);
+  }
+  const rest = s.slice(PREFIX.length);
+  const dot = rest.lastIndexOf('.');
+  if (dot <= 0) throw fail('E_HANDLE', 'handle 缺少校验位：复制时可能被截断，重新取一次');
+  const body = rest.slice(0, dot);
+  const sum = rest.slice(dot + 1);
+  if (checksum(body) !== sum) {
+    throw fail('E_HANDLE', 'handle 校验不通过：内容被改动或截断，重新排一次盘取新的 handle');
+  }
+  let payload;
+  try {
+    payload = JSON.parse(unb64url(body));
+  } catch (e) {
+    throw fail('E_HANDLE', 'handle 内容无法解析（不是本插件生成的句柄），重新排一次盘取新的 handle');
+  }
+  if (!isObject(payload)) throw fail('E_HANDLE', 'handle 内容不是参数对象，重新排一次盘取新的 handle');
+  return payload;
+}
+
+/**
+ * 把 handle 与增量参数并起来。没有 handle 时原样返回（深一层的浅拷贝，避免改调用方对象）。
+ * 增量优先：{ handle, asOf: 2030 } 只覆盖 asOf，其余沿用原参数。
+ */
+export function resolveHandle(args = {}) {
+  if (!isObject(args)) return args;
+  const { handle, ...rest } = args;
+  if (handle === undefined || handle === null || handle === '') return { ...rest };
+  const base = decodeHandle(handle);
+  // 显式的 undefined 当作「没传」：否则 { handle, datetime: undefined } 会把句柄里的日期抹掉
+  const out = { ...base };
+  for (const [k, v] of Object.entries(rest)) {
+    if (v !== undefined) out[k] = v;
+  }
+  return out;
+}
+
+export const HANDLE_PREFIX = PREFIX;
+export const handleChecksum = checksum;

package/engine/index.js

@@ -11,6 +11,8 @@ import { buildQimen, buildSnapshot } from './qimen.js';
 import { geocodeAddress, resolveAddress } from './geo.js';
 import { toJDN, ganzhiName, dayGanzhiIndex } from './calendar.js';
 import { randomOf, isSeed } from './random.js';
+import { encodeHandle, decodeHandle, resolveHandle } from './handle.js';
+import { parseRevision, displayValue } from './revise.js';
 import { interpret, DIRECTIONS, DIRECTION_DEFAULT } from './interpret.js';
 import { followup, askPrompt } from './followup.js';
 import { crossCheck, crossText, crossSection } from './crosscheck.js';
@@ -30,7 +32,7 @@ import { canonicalJson, fingerprintOf } from './fingerprint.js';
 import { buildTrend } from './trend.js';
 import { buildFengshui } from './fengshui.js';
 import { buildName } from './name.js';
-import { buildTrace, SYSTEM_LABEL } from './trace.js';
+import { buildTrace, traceMarkdown, SYSTEM_LABEL } from './trace.js';
 import { fail } from './fail.js';
 import { assertCivil } from './validate.js';
 
@@ -139,10 +141,14 @@ function baziText(r) {
     ? `　有争议：${ysd.map((d) => `${d.element}（${d.favorRole}；${d.climate}盘调候忌${d.element}）`).join('、')}`
     : '';
   const disEls = new Set(ysd.map((d) => d.element));
+  const ysn = (r.frame && r.frame.yongshen && r.frame.yongshen.neutral) || [];
+  const neuText = ysn.length
+    ? `　中性偏忌：${ysn.map((n) => `${n.element} ${n.weight} 分`).join('、')}（近零，不作实忌）`
+    : '';
   const gejuLine = r.frame ? [
     `格局：${r.frame.primary ? `${r.frame.primary.name}（${r.frame.primary.evidence}）` : '—'}`,
     `　　　${r.frame.geju.map((g) => `${g.name}[${g.kind}${g.status ? `·${g.status}` : ''}]`).join('　')}`,
-    `用神：喜${r.frame.yongshen.favor.join('')}（${r.frame.yongshen.favorTenGods.join('、')}）　忌${r.frame.yongshen.avoid.join('')}（${r.frame.yongshen.avoidTenGods.join('、')}）${disText}　${r.frame.yongshen.method}`,
+    `用神：喜${r.frame.yongshen.favor.join('')}（${r.frame.yongshen.favorTenGods.join('、')}）　忌${r.frame.yongshen.avoid.join('')}（${r.frame.yongshen.avoidTenGods.join('、')}）${disText}${neuText}　${r.frame.yongshen.method}`,
     `　　　${r.frame.yongshen.detail}`,
     `寒暖：${r.climate ? `${r.climate.label}（${(r.climate.evidence || []).join('、')}）${r.climate.need ? `　调候取${r.climate.need.stem}${r.climate.need.element}　忌${r.climate.avoidElement}${disEls.has(r.climate.avoidElement) ? '（有争议）' : ''}` : ''}` : '—'}` +
     (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}）` : ''),
@@ -484,7 +490,7 @@ function jsonSafe(value) {
 // 只收影响盘面的参数：地址换成有效经度后不再把原文算进去，问事/方向按体系保留。
 const SHADOW_IGNORE = new Set([
   'shadow', 'shadowVersion', 'diff', 'trace', 'traceError', 'withInterpret', 'cross', 'verifyPast', 'rectify', 'events',
-  'geocode', 'ask', 'followup', 'caliber', 'seed', 'asOf',
+  'geocode', 'ask', 'followup', 'caliber', 'seed', 'asOf', 'handle', 'revise',
 ]);
 
 const num6 = (n) => {
@@ -625,11 +631,11 @@ export function chartFingerprint(args = {}, opts = {}) {
 }
 
 const SHADOW_DIFF_IGNORE = new Set([
-  'shadow', 'trace', 'traceError', 'interpret', 'summary', 'classics', 'suiyunClassic', 'renyuanClassic', 'cross',
+  'shadow', 'trace', 'traceText', 'traceError', 'interpret', 'summary', 'classics', 'suiyunClassic', 'renyuanClassic', 'cross',
   'past', 'rectify', 'followup', 'caliber', 'input', 'reading', 'knowledge', 'outline',
   'sections', 'answer', 'plain', 'tables', 'glossary', 'caveats', 'lead', 'dimensions',
   'moduleType', 'technique', 'disclaimer', 'ask', 'followups', 'knowledgeCount', 'title',
-  'systemLabel',
+  'systemLabel', 'handle', 'handleError', 'revision',
 ]);
 
 function shadowChart(result) {
@@ -693,9 +699,29 @@ export function shadowDiff(previous, current, opts = {}) {
  * @param {object} args
  * @param {'bazi'|'ziwei'|'liuyao'} args.system
  * @param {string} [args.datetime]
+ * @param {string} [args.handle] 上次结果里的句柄；给了它就可以只传增量参数（如 asOf、direction、system）
  */
-export function compute(args = {}) {
+export function compute(input = {}) {
+  // 句柄先并回参数：后面的代码只看见一份完整参数，不必到处判 handle
+  let args = resolveHandle(input);
+  // 一句话改参（C2）：把「换成紫微看 2030 年事业」翻成补丁再排盘；识别不到就原样排，
+  // 绝不猜。改了哪些、没认哪些都随结果回传，便于核对。
+  let revision;
+  if (typeof args.revise === 'string' && args.revise.trim()) {
+    const rev = parseRevision(args.revise);
+    const before = { ...args };
+    args = { ...args, ...rev.patch };
+    revision = {
+      text: rev.text,
+      applied: rev.labels.map((l) => {
+        const from = before[l.key] === undefined ? null : before[l.key];
+        return { ...l, from, fromDisplay: displayValue(l.key, from) };
+      }),
+      ignored: rev.ignored,
+    };
+  }
   const r = jsonSafe(computeRaw(args));
+  if (revision) r.revision = revision;
   if (r && r.system === 'bazi') {
     r.classics = classicsFor(r);
     const ct = classicsText(r.classics);
@@ -788,7 +814,11 @@ export function compute(args = {}) {
   if (args.trace === true) {
     try {
       const layers = buildTrace(r, { direction: args.direction, gender: args.gender });
-      if (layers) r.trace = layers;
+      if (layers) {
+        r.trace = layers;
+        // 同一份层另出一份 Markdown：贴进对话/文档时表格不会散架，内容与 r.trace 同源
+        r.traceText = traceMarkdown(layers, { system: r.system });
+      }
     } catch (e) {
       r.traceError = String((e && e.message) || e);
     }
@@ -801,6 +831,13 @@ export function compute(args = {}) {
       r.shadow = { error: String((e && e.message) || e) };
     }
   }
+  // 排盘句柄：把这张盘的参数压成短串；下一次追问传 handle + 增量即可，不必重报出生信息
+  try {
+    const h = encodeHandle(args);
+    if (h) r.handle = h;
+  } catch (e) {
+    r.handleError = String((e && e.message) || e);
+  }
   return r;
 }
 
@@ -1551,6 +1588,17 @@ export function renderText(result) {
       + (s.reproducible === false ? `\n　⚠ 不可复算：${s.reason}` : '')
       + (s.reproducible === true && s.asOfPinned === false && (s.system === 'bazi' || s.system === 'ziwei') ? '\n　提示：未固定 asOf，流年/流月随「此刻」变化；要比对请传 asOf。' : ''));
   }
+  // 一句话改参的回显：改了哪些、没认哪些，都摆出来让人核对，而不是悄悄按新参数排
+  if (result.revision && ((result.revision.applied || []).length || (result.revision.ignored || []).length)) {
+    const rev = result.revision;
+    const rows = (rev.applied || []).map((a) => `${a.label}：${a.fromDisplay == null ? '（未设）' : a.fromDisplay} → ${a.display}`);
+    parts.push(`【改参】${rev.text}${rows.length ? `\n　${rows.join('；')}` : '\n　没有识别到可改的参数，仍按原参数排盘'}`
+      + ((rev.ignored || []).length ? `\n　未处理：${rev.ignored.join('；')}` : ''));
+  }
+  // 句柄放进文本：模型看到的是这段摘要，不给它就没法在下一轮只传增量
+  if (typeof result.handle === 'string' && result.handle) {
+    parts.push(`【排盘句柄】${result.handle}\n　追问同一张盘：传 handle + 增量参数（asOf / direction / question，或换 system 看另一套盘），不必重报出生信息。`);
+  }
   if (Array.isArray(result.trace) && result.trace.length) {
     parts.push(`【推导链】${SYSTEM_LABEL[result.system] || result.system} · ${result.trace.length} 层\n`
       + result.trace.map((t, i) => `${i + 1}. ${t.field}｜${t.result}\n　规则：${t.rule}　出处：${t.source}`).join('\n'));
@@ -1598,7 +1646,8 @@ export { pastSignals, verifyFit, rectifyBirth };
 export { crossCheck, crossText, crossSection };
 export { buildAlmanac, buildZeri, buildChenggu, buildXiaoliuren, buildStar, buildNumerology, buildConvert };
 export { buildTrend, buildFengshui, buildName };
-export { buildTrace };
+export { buildTrace, traceMarkdown };
+export { encodeHandle, decodeHandle, resolveHandle };
 
 
 

package/engine/interpret-plain.js

@@ -170,10 +170,13 @@ export function buildAnswer(r, ask, ctx = {}) {
     const ys = (r.frame && r.frame.yongshen) || {};
     const favor = join(ys.favor);
     const avoid = join(ys.avoid);
+    const neu = Array.isArray(ys.neutral) && ys.neutral.length
+      ? `（其中${ys.neutral.map((n) => n.element).join('、')}在命局里几乎没有分量，算中性偏忌，不必刻意避）`
+      : '';
     const ln = (r.liunian || [])[0];
     const parts = [
       head + `先说结论：你是${s(dm.stem)}${s(dm.element)}日主，命局${s(st.level, '待定')}` +
-        `${favor ? `，顺${favor}、忌${avoid}——往${favor}的方向安排事情会更省力` : ''}。`,
+        `${favor ? `，顺${favor}、忌${avoid}${neu}——往${favor}的方向安排事情会更省力` : ''}。`,
       ln && ln.ganzhi
         ? `${s(ln.year)} 年是${ln.ganzhi}年（${s(ln.luck && ln.luck.tier, '平')}），这是「大环境」这一层。`
         : '',

package/engine/interpret.js

@@ -171,6 +171,10 @@ function baziInterpret(r) {
   const favor = Array.isArray(ys.favor) ? ys.favor : [];
   const avoid = Array.isArray(ys.avoid) ? ys.avoid : [];
   const disputed = Array.isArray(ys.disputed) ? ys.disputed : [];
+  const neutral = Array.isArray(ys.neutral) ? ys.neutral : [];
+  const neutralText = neutral.length
+    ? `其中${neutral.map((n) => `${n.element}（${n.role}）`).join('、')}全局仅 ${neutral.map((n) => n.weight).join('、')} 分，分量近零，按中性偏忌看；仍留在忌里，是因为行运走到这一行时照样按忌计。`
+    : '';
   const primary = pick(frame, 'primaryName', '未取定');
   const gender = pick(r.input, 'gender', '');
   const isMale = gender === 'male';
@@ -338,7 +342,7 @@ function baziInterpret(r) {
 
   const frameworkText = [
     `**日主**：${dm.stem}${dm.element}（${dm.yinYang}${dm.element}）${season ? `生于${season.branch}月，日主在月令「${season.word}」` : ''}，命局${level}（${pick(st, 'score', '—')} 分）${stemP ? `——${stemP.image}之象` : ''}。`,
-    `**用神**：喜${join(favor) || '—'}（${join(ys.favorRoles || []) || '—'}），忌${join(avoid) || '—'}（${join(ys.avoidRoles || []) || '—'}）。${frameToneOf(level, favorRolesByWeight)}`,
+    `**用神**：喜${join(favor) || '—'}（${join(ys.favorRoles || []) || '—'}），忌${join(avoid) || '—'}（${join(ys.avoidRoles || []) || '—'}）。${neutral.length ? `（${join(neutral.map((n) => n.element))} 近零，按中性偏忌看）` : ''}${frameToneOf(level, favorRolesByWeight)}`,
     `**格局**：${primary}（${pick(frame.primary, 'evidence', '')}）${(Array.isArray(frame.geju) ? frame.geju : []).filter((g) => g.name && g.name !== primary).length
       ? `，另有${frame.geju.map((g) => g.name).filter((n) => n && n !== primary).join('、')}`
       : ''}。`,
@@ -473,7 +477,7 @@ function baziInterpret(r) {
       key: 'yongshen', label: '用神与忌神',
       // detail 里通常已含调候说明，这里不再补一句，避免同一段出现两次「调候上…」
       text: `喜用：${join(favor)}（对应十神：${join(ys.favorTenGods || ys.favorRoles || [])}）；忌：${join(avoid)}（对应十神：${join(ys.avoidTenGods || ys.avoidRoles || [])}）。` +
-        `${pick(ys, 'detail', '')}`,
+        neutralText + `${pick(ys, 'detail', '')}`,
     },
     ...(cli ? [{
       key: 'climate', label: '寒暖燥湿',
@@ -515,7 +519,7 @@ function baziInterpret(r) {
   // 一页读懂：报告顶部的五条结论（整体 / 事业 / 财富 / 感情 / 节奏）。
   // 只做「摘要」，不引入新判断——全部取自下面已经算好的字段。
   const outline = [
-    { key: 'overall', label: '整体', text: `${level}，喜${join(favor) || '—'}、忌${join(avoid) || '—'}` },
+    { key: 'overall', label: '整体', text: `${level}，喜${join(favor) || '—'}、忌${join(avoid) || '—'}${neutral.length ? `（${join(neutral.map((n) => n.element))} 近零·中性偏忌）` : ''}` },
     { key: 'career', label: '事业', text: `主格${primary}，${topName}偏旺` },
     { key: 'wealth', label: '财富', text: `财星权重 ${groups['财'] ?? 0}${favor.includes('金') ? '，喜金助财' : ''}` },
     { key: 'love', label: '感情', text: `${spouseKey}星权重 ${groups[spouseKey] ?? 0}，日支 ${pick(r.pillars?.day, 'branch', '—')}` },