dsh-metaphysics 0.61.2 → 0.62.0

package/engine/tarot.js

@@ -13,6 +13,8 @@
 //     不采用「逆位即纯凶」的流派；不同流派对逆位的取舍不同，此处取中性偏提醒。
 // 以上差异在 reading 与结果字段 systemNote 中均有标注，避免被当作唯一正解。
 import { CARD_LIB, CARD_COUNTS } from './tarot-cards.js';
+import { fail } from './fail.js';
+import { assertObject } from './validate.js';
 
 const MAJOR = [
   ['愚者', '0', '新开始 冒险 纯真 无限可能', '鲁莽 逃避 原地打转 不切实际'],
@@ -289,7 +291,15 @@ function stamp(at) {
  * 生成解读（确定性：同样的 question + cards 必得同样的段落）
  * 段落数固定 6-8：开场 / 逐张（1-3 张各一段；5 张按 2+3 分两段）/ 结构 / 关键牌 / 建议 / 收尾
  */
-export function tarotReading({ question = '', cards = [] } = {}) {
+export function tarotReading(input = {}) {
+  assertObject(input, 'tarotReading 的参数', '{ question?, cards }：cards 用 drawTarot 抽出的牌面对象数组');
+  const question = input.question;
+  // cards 不是数组（字符串、对象）以前会被 filter 成空，回一句「没有抽到牌面」——
+  // 那是参数形状错了，不是真的没牌。
+  if (input.cards !== undefined && input.cards !== null && !Array.isArray(input.cards)) {
+    throw fail('E_INPUT', `tarotReading 的 cards 必须是牌面对象数组（drawTarot 的 cards），收到 ${typeof input.cards}`);
+  }
+  const cards = input.cards;
   const q = String(question || '').trim();
   const list = (Array.isArray(cards) ? cards : []).filter((c) => c && c.name);
   const n = list.length;
@@ -324,8 +334,9 @@ export function tarotReading({ question = '', cards = [] } = {}) {
       const ast = meta.astro ? `它对应的占星位置是${meta.astro}，` : '';
       const role = !ast && meta.role ? `它在这里顶的是「${meta.role}」那个角色，` : '';
       const core = meta.core ? `它的核心是「${meta.core}」。` : '';
+      const posName = c.position || `第 ${i + 1} 张`;
       const tail = POS_TAIL[c.position] || '把它放回你的处境里对照，看看哪一句戳中了你。';
-      return `${c.position}（${hint}）是「${c.name}」${ori}：${kws}。${img}${ast}${role}${core}${oriNote}。${tail}`;
+      return `${posName}（${hint}）是「${c.name}」${ori}：${kws}。${img}${ast}${role}${core}${oriNote}。${tail}`;
     });
     paras.push(lines.join(''));
   }
@@ -371,7 +382,8 @@ export function tarotReading({ question = '', cards = [] } = {}) {
     : revCard
       ? '全盘没有大阿卡纳，关节就落在第一张逆位上——那股还没顺过来的力量'
       : '全盘既没有大阿卡纳也没有逆位，走势平顺，就以第一张为参照';
-  paras.push(`全盘的关节是「${key.name}」（${key.position}·${key.upright === false ? '逆位' : '正位'}）${keyMeta.core ? `，${keyMeta.core}` : ''}。${keyReason}；其余几张可以看作它在不同位置上的回声。`);
+  const keyPos = key.position || `第 ${list.indexOf(key) + 1} 张`;
+  paras.push(`全盘的关节是「${key.name}」（${keyPos}·${key.upright === false ? '逆位' : '正位'}）${keyMeta.core ? `，${keyMeta.core}` : ''}。${keyReason}；其余几张可以看作它在不同位置上的回声。`);
 
   // ⑤ 建议：据牌面给 2-3 条可执行的行动建议
   const tips = [];
@@ -381,7 +393,7 @@ export function tarotReading({ question = '', cards = [] } = {}) {
   if (missing.length) tips.push(`补一点${missing[0]}的力量：${ELEM_TIP[missing[0]]}`);
   else if (heavy) tips.push(`${dominant}已经偏旺，${ELEM_WARN[dominant]}`);
   const adviceCard = list.find((c) => c.position === '建议');
-  if (adviceCard) tips.push(`把「${adviceCard.name}」${adviceCard.orientation}的关键词（${(adviceCard.keywords || []).join('、')}）当作接下来一周的小练习`);
+  if (adviceCard) tips.push(`把「${adviceCard.name}」${adviceCard.upright === false ? '逆位' : '正位'}的关键词（${(adviceCard.keywords || []).join('、')}）当作接下来一周的小练习`);
   const picked = tips.slice(0, 3);
   paras.push(`建议：其一，${picked[0]}；其二，${picked[1]}${picked[2] ? `；其三，${picked[2]}` : ''}。`);
 
@@ -392,8 +404,14 @@ export function tarotReading({ question = '', cards = [] } = {}) {
 }
 
 /** 抽牌：count 张，按牌阵给出位置。random 可注入（配合 seed 复现同一次抽牌） */
-export function drawTarot({ count = 3, question = '', at, random = Math.random } = {}) {
-  const n = [1, 3, 5].includes(count) ? count : 3;
+export function drawTarot(input = {}) {
+  const { count: rawCount, question = '', at, random = Math.random } = input || {};
+  let count = rawCount;
+  if (count === undefined || count === null || count === '') count = 3;
+  const n = Number(count);
+  if (![1, 3, 5].includes(n)) {
+    throw fail('E_INPUT', `塔罗张数只能是 1 / 3 / 5，收到「${count}」`);
+  }
   const rand = typeof random === 'function' ? random : Math.random;
   const deck = tarotDeck();
   for (let i = deck.length - 1; i > 0; i--) {

package/engine/tiaohou.js

@@ -42,8 +42,10 @@ const NEED = {
   寒燥: { element: '火', stem: '丙', avoid: '水', why: '天寒地干，先要一点阳和之气' },
   寒: { element: '火', stem: '丙', avoid: '水', why: '冬令气寒，非火不暖' },
   温热: { element: '水', stem: '壬', avoid: '火', why: '火气初旺，得水润泽才好用' },
+  // 热且湿：闷蒸之局。解法仍是泄热（壬水），不是「湿气重就加火」——那等于往蒸笼下添柴。
+  // 单列一档而不是并进「湿滞」，是因为湿滞属不热之湿（土湿要火蒸），两者取用相反。
+  湿热: { element: '水', stem: '壬', avoid: '火', why: '湿热交蒸，得壬水引热下行，再添火只会更闷' },
   燥热: { element: '水', stem: '壬', avoid: '火', why: '火炎土燥，非水不润' },
-  热: { element: '水', stem: '壬', avoid: '火', why: '夏令炎威，先求一泓清水' },
   湿滞: { element: '火', stem: '丙', avoid: '水', why: '湿气郁结，要火来蒸腾' },
   燥: { element: '水', stem: '壬', avoid: '火', why: '气燥不润，得水则舒' },
   平和: { element: null, stem: null, avoid: null, why: '寒暖相济，气候不是这一盘的主要矛盾' },
@@ -51,7 +53,7 @@ const NEED = {
 
 const KIND_NAME = {
   寒湿: '寒湿', 寒燥: '寒燥', 寒: '寒',
-  温热: '温热', 燥热: '燥热', 热: '热',
+  温热: '温热', 湿热: '湿热', 燥热: '燥热',
   湿滞: '湿滞', 燥: '燥', 平和: '平和',
 };
 
@@ -92,12 +94,12 @@ const DAY_FEEL = {
     金: '金在燥热里容易发烫变形，要水来淬',
     水: '水在燥热里最珍贵，一滴都不能浪费',
   },
-  热: {
-    木: '木在暑天要水，不然只长叶不结果',
-    火: '火已经当令，收着用比放出去更划算',
-    土: '土热则燥，得水则安',
-    金: '金在暑天要水来洗，才见光泽',
-    水: '水在暑天是命脉，要保住源头',
+  湿热: {
+    木: '木沤在湿热里容易烂根生虫，先要疏泄，不能再烘',
+    火: '火在闷热里只会更闷，得引一点水气把它透开',
+    土: '土湿热成泥沼，得疏得泄，再烘只会更黏',
+    金: '金在湿热里容易生锈，要泄热、要见燥，才显出锋',
+    水: '水不算少却带着热，得把热泄出去，水才用得干净',
   },
   湿滞: {
     木: '木泡在水里会烂根，先要疏土透气',
@@ -157,8 +159,11 @@ export function judgeClimate({ monthBranch, dayStem, wuxing = {}, branches = []
   else if (cold && drySide) kind = '寒燥';
   else if (cold) kind = '寒';
   else if (hot && drySide) kind = '燥热';
+  // 先判「热且湿」再判「单纯热」：原来 hot 先短路，hot && damp>=0.8 永远走不到。
+  // 接通它要单开一档「湿热」而不是套用「湿滞」：湿滞是不热之湿（要丙火蒸），
+  // 热而湿则是闷蒸（要壬水泄热）——复用湿滞会把偏热盘的喜用从水翻成火。
+  else if (hot && wetSide) kind = '湿热';
   else if (hot) kind = '温热';
-  else if (hot && damp >= 0.8) kind = '湿滞';
   else if (drySide) kind = '燥';
   else if (wetSide) kind = '湿滞';
 
@@ -200,7 +205,9 @@ function buildNarration({ kind, monthBranch, dayElement, need, fire, water }) {
   if (!need.element) {
     return `${head}。${feel}。调候不是这一盘的主要矛盾，取用仍以扶抑为主，寒暖只作微调。`;
   }
-  return `${head}。${feel}。所以这一局要的不是更多的${kind.includes('寒') ? '水' : '火'}，而是${need.stem}${need.element}——${need.why}。`;
+  // 「不该再多的是什么」按 NEED 的忌神填，不按档名猜：猜「寒→水、其它→火」时，
+  // 湿滞（忌水、取丙火）会念成「要的不是更多的火，而是丙火」。
+  return `${head}。${feel}。所以这一局要的不是更多的${need.avoid}，而是${need.stem}${need.element}——${need.why}。`;
 }
 
 /** 调候与扶抑的仲裁说明：冲突时把话说明白，不静默取一个 */

package/engine/trend.js

@@ -5,6 +5,7 @@
 // 只用于看形态与相对起伏；分高不等于真实吉凶，旺衰落在换档边界时连排序都不给。
 import { buildBazi, HIDDEN_STEMS, tenGod } from './bazi.js';
 import { ganzhiName, sexagenaryIndex, STEMS, BRANCHES } from './calendar.js';
+import { fail } from './fail.js';
 
 // ── 十神计分表 ────────────────────────────────────────────────
 // 三张表各自求和接近 0，保证分数有正负双向起伏；符号随日主旺衰方向翻转：
@@ -86,9 +87,17 @@ function buildSegments(list, direction, birthYear, toAge) {
 export function buildTrend(input) {
   const gender = input.gender;
   if (gender !== 'male' && gender !== 'female') {
-    throw new Error('人生 K 线需要性别：大运顺逆由性别决定，不可缺省');
+    throw fail('E_INPUT', '人生 K 线需要性别：大运顺逆由性别决定，不可缺省');
+  }
+  // 以前 toAge 只认整数：50.5 会被静默换成默认 100 岁，点数翻倍还看不出来
+  let toAge = 100;
+  if (input.toAge !== undefined && input.toAge !== null && input.toAge !== '') {
+    const n = Number(input.toAge);
+    if (!Number.isInteger(n) || n < 10 || n > 100) {
+      throw fail('E_INPUT', `toAge 要是 10–100 的整数（岁），收到「${input.toAge}」`);
+    }
+    toAge = n;
   }
-  const toAge = clamp(Number.isInteger(input.toAge) ? input.toAge : 100, 10, 100);
   const r = buildBazi({
     year: input.year,
     month: input.month,

package/engine/validate.js

@@ -54,3 +54,33 @@ export function assertCivil(input, who = '') {
   if (minute < 0 || minute > 59) throw fail('E_INPUT', `${p}minute 超出范围 0–59（收到 ${minute}）`);
   return input;
 }
+
+/**
+ * 次级入口（build* 之外的导出函数）的形状守卫。
+ * 这些函数以前直接读 input.surname / hex.lower / bits.slice，传错形状时在深处抛裸 TypeError，
+ * 调用方只看见 "Cannot read properties of null"，看不出是自己传错了什么。
+ * @param {*} value 待校验入参
+ * @param {string} who 函数名或参数名，用于定位
+ * @param {string} shape 该传什么（写清字段，别让调用方去猜）
+ */
+export function assertObject(value, who, shape) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    const got = value === null ? 'null' : value === undefined ? 'undefined' : Array.isArray(value) ? '数组' : typeof value;
+    throw fail('E_INPUT', `${who} 必须是对象（收到 ${got}）；${shape}`);
+  }
+  return value;
+}
+
+/**
+ * 晚子时换日（23:00–23:59 归次日）之后再量一次年份闸门。
+ * 2400-12-31T23:30 能过入参校验，却被整体搬到 2401 出盘；而直接传 2401-01-01T00:30 会被拒。
+ * 同一张盘不该有「换日就通、直填就拒」两条口径——边界附近的输入必须同进同出。
+ */
+export function assertShifted(date, who = '') {
+  const p = who ? `${who}：` : '';
+  if (date.year < MIN_YEAR || date.year > MAX_YEAR) {
+    throw fail('E_RANGE', `${p}晚子时按次日归后落到 ${date.year}-${String(date.month).padStart(2, '0')}-${String(date.day).padStart(2, '0')}，`
+      + `超出可计算范围 ${MIN_YEAR}–${MAX_YEAR}；请把时刻挪到 23 点前，或换一天起课`);
+  }
+  return date;
+}

package/engine/xiaoliuren.js

@@ -2,7 +2,10 @@
 // 口径：通行掌诀；断语为白话提炼（非原文照录）。轻量快占，属民俗参考。
 import { solarToLunar } from './lunar.js';
 import { hourToBranch } from './almanac.js';
-import { BRANCHES } from './calendar.js';
+import { BRANCHES, fromJDN, toJDN } from './calendar.js';
+import { parseYmd } from './datetime.js';
+import { assertShifted } from './validate.js';
+import { fail } from './fail.js';
 
 /** 六宫：吉凶 + 白话断语。 */
 export const PALACES = {
@@ -24,6 +27,9 @@ const pick = (n) => PALACE_ORDER[(((n - 1) % 6) + 6) % 6];
  *   time 模式下 date 与 hour 必须成对（缺时辰则同一天任何时刻同宫，等于静默代填）。
  */
 export function buildXiaoliuren(input) {
+  if (!input || typeof input !== 'object') {
+    throw fail('E_INPUT', '小六壬起课参数不能为空：时间起课要 date / hour，数字起课要 num1 / num2 / num3');
+  }
   const mode = input.mode === 'number' ? 'number' : 'time';
   let m;
   let d;
@@ -31,20 +37,35 @@ export function buildXiaoliuren(input) {
   let originText;
   if (mode === 'time') {
     if (typeof input.hour !== 'number' || !Number.isInteger(input.hour) || input.hour < 0 || input.hour > 23) {
-      throw new Error('时间起课必须同时给 date 与 hour（0–23）：掐指按时辰推进，缺时辰不可代填');
+      throw fail('E_INPUT', '时间起课必须同时给 date 与 hour（0–23）：掐指按时辰推进，缺时辰不可代填');
+    }
+    const mt = parseYmd(input.date, 'date');
+    if (!mt) {
+      throw fail('E_INPUT', input.date
+        ? `date 不是真实存在的公历日期：「${input.date}」，请用 2026-12-01 这种格式`
+        : '时间起课需要 date（公历 YYYY-MM-DD）——请向用户询问日期');
+    }
+    // 晚子时换日与八字/六壬/奇门同口径：23:00–23:59 归次日，否则同一子时前后会落到两个日子
+    let y = mt.year;
+    let mo = mt.month;
+    let dy = mt.day;
+    const lateZi = input.lateZi !== false;
+    if (lateZi && input.hour >= 23) {
+      const next = assertShifted(fromJDN(toJDN(y, mo, dy) + 1), '小六壬时间起课');
+      y = next.year;
+      mo = next.month;
+      dy = next.day;
     }
-    const mt = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(String(input.date || '').trim());
-    if (!mt) throw new Error('时间起课需要 date（公历 YYYY-MM-DD）——请向用户询问日期');
-    const lunar = solarToLunar(Number(mt[1]), Number(mt[2]), Number(mt[3]));
+    const lunar = solarToLunar(y, mo, dy);
     const branch = hourToBranch(input.hour);
     m = lunar.month;
     d = lunar.day;
     h = BRANCHES.indexOf(branch) + 1;
-    originText = `农历${lunar.month}月${lunar.day}日 ${branch}时：月${m} → 日${d} → 时${h} 掐指落宫`;
+    originText = `农历${lunar.month}月${lunar.day}日 ${branch}时：月${m} → 日${d} → 时${h} 掐指落宫${lateZi && input.hour >= 23 ? '（晚子时按次日）' : ''}`;
   } else {
     const nums = [input.num1, input.num2, input.num3].map(Number);
     if (nums.some((x) => !Number.isInteger(x) || x < 1 || x > 99)) {
-      throw new Error('报数起课需要三个 1–99 的正整数（随口报即可）——缺数请向用户索要，不要代填');
+      throw fail('E_INPUT', '报数起课需要三个 1–99 的正整数（随口报即可）——缺数请向用户索要，不要代填');
     }
     [m, d, h] = nums;
     originText = `报数 ${m}、${d}、${h}：依次按月/日/时位掐指落宫`;

package/engine/yingqi.js

@@ -29,13 +29,6 @@ const BRANCHES_OF = (() => {
   return out;
 })();
 
-export const YINGQI_RULE_IDS = [
-  'jing-zhi-chong', 'dong-he-zhi', 'taiwang-mu-chong', 'shuaijue-sheng-wang',
-  'rumu-chong-kai', 'liuhe-xiang-ji', 'yuepo-xi-tian', 'xunkong-tian-chong',
-  'jixiang-keshen-shouke', 'xiong-keshen-fengsheng', 'huajin-zhi-he',
-  'huatui-ji-zhi-chong', 'bianyao-dongyao', 'shikong-yuanshen-zhi', 'shishuai-yuanshen-chong',
-];
-
 /**
  * 规则的排列顺序 = 原文《各門類應期總注章第又二十六》19 条的罗列次序。
  *
@@ -69,6 +62,9 @@ export const RULE_ORDER = [
   'shishuai-yuanshen-chong',
 ];
 
+/** 规则编号表：与 RULE_ORDER 同一批规则，保留此导出名给老调用方 */
+export const YINGQI_RULE_IDS = RULE_ORDER;
+
 // 条文里给出、但落不到「某支」上的条目：列出来，避免被误以为已经做了
 export const NOT_IMPLEMENTED = [
   '問有應於獨發獨靜：詳獨發章（要判「獨發/獨靜」整卦只有一爻動，属整卦层，未并入单爻规则）',
@@ -108,7 +104,6 @@ export function yingqiState(line, bianLine, ctx = {}) {
   if (day && heOf(branch) === day) heWith.push({ with: '日辰', branch: day });
   if (moving && bianBranch && heOf(branch) === bianBranch) heWith.push({ with: '变爻', branch: bianBranch });
   // 太旺：月建同气（旺/相）且日辰生扶或比和
-  const monthTone = month ? (BRANCHES_OF[zhiElementOf(month)] || []) : [];
   const monthSame = !!(month && zhiElementOf(month) === element);
   const monthSheng = !!(month && zhiElementOf(month) === SHENG_ME[element]);
   const daySame = !!(day && zhiElementOf(day) === element);
@@ -121,7 +116,7 @@ export function yingqiState(line, bianLine, ctx = {}) {
   return {
     branch, element, moving, bianBranch, jinTui: jt, kongHit, monthPo, ruMu,
     heWith, taiWang, shuaiJue, monthSame, monthSheng, daySame, daySheng, monthKe,
-    muBranch, monthSameBranches: monthTone,
+    muBranch,
   };
 }
 

package/engine/zeri.js

@@ -1,6 +1,8 @@
 // 择日：逐日按《协纪辨方书》卷十一「用事」命中宜忌，再用卷十「宜忌」六等与德神制化定吉凶方向，
 // 叠冲属相排除后排序。口径透明：这是排序引导，不是吉凶断语。
 import { fromJDN, toJDN } from './calendar.js';
+import { parseYmd } from './datetime.js';
+import { MAX_YEAR } from './validate.js';
 import { buildAlmanac, SHENGXIAO } from './almanac.js';
 import {
   computeDayShensha, taskShenshaHits, xingHitText, gradeDay,
@@ -105,23 +107,6 @@ const verdictOf = (grade, ctx) => {
   return { verdict: '回避', text: `卷十作 ${basis}；${tally}，${why}传统作诸事皆忌。`, excluded: false };
 };
 
-/**
- * 择日主函数。
- * @param {{task:string, startDate:string, days?:number, shengXiao?:string}} input
- *   startDate 必填（公历 YYYY-MM-DD），避免引擎在无时钟环境下静默取「今天」。
- */
-/** 严格解析公历日期：2 月 30 日这类不存在的日子直接判非法，不滚到下个月 */
-function parseYmd(raw) {
-  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(String(raw || '').trim());
-  if (!m) return null;
-  const year = Number(m[1]);
-  const month = Number(m[2]);
-  const day = Number(m[3]);
-  if (month < 1 || month > 12 || day < 1) return null;
-  const back = fromJDN(toJDN(year, month, day));
-  return back.year === year && back.month === month && back.day === day ? { year, month, day } : null;
-}
-
 const ymd = (p) => `${p.year}-${String(p.month).padStart(2, '0')}-${String(p.day).padStart(2, '0')}`;
 
 /**
@@ -132,6 +117,9 @@ const ymd = (p) => `${p.year}-${String(p.month).padStart(2, '0')}-${String(p.day
  *   candidates 给了就只比这几个候选日（2–12 个，去重、保持输入顺序），startDate 与 days 不参与。
  */
 export function buildZeri(input) {
+  if (!input || typeof input !== 'object') {
+    throw bad('择日参数不能为空：要给 task 与 startDate（或 candidates）');
+  }
   const task = input.task;
   if (!TASKS[task]) throw bad(`不支持的事项「${task}」。支持：${Object.keys(TASKS).join('、')}`);
   const shengXiaoRaw = typeof input.shengXiao === 'string' ? input.shengXiao.trim() : '';
@@ -149,7 +137,7 @@ export function buildZeri(input) {
     const seen = new Set();
     candidates = [];
     for (const raw of input.candidates) {
-      const p = parseYmd(raw);
+      const p = parseYmd(raw, '候选日');
       if (!p) throw bad(`候选日不是真实存在的公历日期：「${raw}」，请用 2026-12-01 这种格式`);
       const key = ymd(p);
       if (seen.has(key)) continue;
@@ -162,9 +150,12 @@ export function buildZeri(input) {
   let start = null;
   let days = 0;
   if (!candidates) {
-    const m = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(String(input.startDate || '').trim());
-    if (!m) throw bad('择日需要 startDate（公历 YYYY-MM-DD）——请向用户询问起算日，不要代填');
-    start = { year: Number(m[1]), month: Number(m[2]), day: Number(m[3]) };
+    start = parseYmd(input.startDate, 'startDate');
+    if (!start) {
+      throw bad(input.startDate
+        ? `startDate 不是真实存在的公历日期：「${input.startDate}」，请改用 2026-12-01 这种格式`
+        : '择日需要 startDate（公历 YYYY-MM-DD）——请向用户询问起算日，不要代填');
+    }
     // days 以前只认 Number.isInteger，于是 "45"（模型很爱给字符串）与 45.5 都静默变成 30 天：
     // 用户要的区间被悄悄改短，而结果里只看得到实际扫了几天，看不出被改过。
     // 现在：能规范成整数的（含数字串）就规范，范围外或非数字一律报错，不猜。
@@ -177,6 +168,13 @@ export function buildZeri(input) {
       if (n < 1 || n > 60) throw bad(`择日的 days 要在 1–60 之间（${n} 超出范围）；更长请用分段多次查询`);
       days = n;
     }
+    // 区间会一路扫到 start+days-1，越界得在这里说清楚：
+    // 让 buildAlmanac 去抛「黄历 的 year 超出支持范围」，用户填的是 startDate，跟黄历没关系。
+    const end = fromJDN(toJDN(start.year, start.month, start.day) + days - 1);
+    if (end.year > MAX_YEAR) {
+      throw fail('E_RANGE', `择日区间超出可计算范围：${ymd(start)} 起 ${days} 天会走到 ${ymd(end)}（上限 ${MAX_YEAR}-12-31）；`
+        + '请把 startDate 提前或减少 days');
+    }
   }
 
   const spec = TASKS[task];

package/engine/ziwei-hepan.js

@@ -17,7 +17,9 @@ const MUT_SCORE = { 禄: 10, 权: 5, 科: 8, 忌: -10 };
 const STRONG_LANDS = ['命宫', '夫妻', '福德', '财帛', '官禄'];
 
 const palaceByBranch = (chart, branch) => (chart.palaces || []).find((p) => p.branch === branch) || null;
-const mainStars = (p) => (p && p.stars ? p.stars.filter((s) => s.type === 'main' || s.type === '吉星' || s.type === '煞星').map((s) => s.name) : []);
+// buildZiwei 的星型标签是中文字面量：主星 / 辅星 / 吉星 / 煞星 / 杂曜。
+// 这里原先写 'main'，永远命中不了，合盘双方便只剩吉星与煞星。
+const mainStars = (p) => (p && p.stars ? p.stars.filter((s) => s.type === '主星' || s.type === '吉星' || s.type === '煞星').map((s) => s.name) : []);
 
 /** 一方的某宫（按地支）在对方盘中落到哪个宫位 */
 function landOn(host, branch) {

package/engine/ziwei-words.js

@@ -124,13 +124,14 @@ export const HUA_READ = {
   忌: { key: '执', gist: '容易在意、反复，是心里放不下的那一块' },
 };
 
-// ── 庙旺得利平不陷：同一条结论的七种语气 ──────────────────────────
+// ── 庙旺得利平闲不陷：同一条结论的语气档（含五档亮度表里的「闲」）─────────
 export const BRIGHT_READ = {
   庙: { word: '得地', tone: 'good', plain: '长处放得开，几乎是本色出演' },
   旺: { word: '有力', tone: 'good', plain: '特点容易显出来，做事有底气' },
   得: { word: '尚可', tone: 'neutral', plain: '能用，需要一点外力配合' },
   利: { word: '中平', tone: 'neutral', plain: '长处与短板都在，看怎么用' },
   平: { word: '偏弱', tone: 'neutral', plain: '不太争得到位置，宜借势' },
+  闲: { word: '闲地', tone: 'neutral', plain: '可用的力不多，宜顺势而不宜硬求' },
   不: { word: '不得地', tone: 'bad', plain: '长处不容易使上，得多绕一步' },
   陷: { word: '失地', tone: 'bad', plain: '容易往负面走，更需要自觉' },
 };

package/engine/ziwei.js

@@ -3,10 +3,11 @@ import { STEMS, BRANCHES, ganzhiName, sexagenaryIndex, jdToParts, partsToJd, for
 import { solarToLunar } from './lunar.js';
 import { applyTrueSolar } from './bazi.js';
 import { applyDst } from './dst.js';
-import { assertCivil } from './validate.js';
+import { assertCivil, assertShifted } from './validate.js';
 import { nayinOf } from './nayin.js';
 import { resolveAddress } from './geo.js';
 import { placeZuoyao, zuoyaoVerseBlock, ZUOYAO_SKIPPED } from './ziwei-zuoyao.js';
+import { SHA_STAR } from './ziwei-words.js';
 
 const fix = (i) => ((i % 12) + 12) % 12;
 
@@ -102,7 +103,7 @@ export const ZIWEI_SCHOOL_OPTIONS = Object.freeze({
   tianmaSchool: ['year-branch', 'month-branch'],
   tiankongSchool: ['off', 'normal', 'shun-jia-shi'],
   jiekongSchool: ['off', 'double', 'single', 'zhanyan'],
-  kuiyueSchool: ['qs1', 'qs2', 'zhong-yiming', 'network'],
+  kuiyueSchool: ['qs1', 'qs2', 'zhong-yiming'],
   tianshiTianshang: ['normal', 'zhongzhou'],
   changshengSchool: ['yin-yang-shun-ni', 'shui-tu', 'huo-tu'],
   lateZishi: ['current-day', 'next-day', 'all-current', 'day-cur-time-next'],
@@ -224,7 +225,7 @@ function mutagenOf(stem, schools) {
   return MUTAGEN[stem] ?? {};
 }
 
-// 安魁钺四派：差异集中在庚辛壬癸年
+// 安魁钺三派：差异集中在庚辛壬癸年（「网络派」与 qs1 同表，不单列）
 export const KUI_YUE_SCHOOLS = {
   qs2: {
     甲: [1, 7], 戊: [1, 7], 庚: [6, 2], 乙: [0, 8], 己: [0, 8],
@@ -234,10 +235,6 @@ export const KUI_YUE_SCHOOLS = {
     甲: [1, 7], 戊: [1, 7], 庚: [2, 6], 乙: [0, 8], 己: [0, 8],
     丙: [11, 9], 丁: [11, 9], 辛: [2, 6], 壬: [5, 3], 癸: [5, 3],
   },
-  network: {
-    甲: [1, 7], 戊: [1, 7], 庚: [1, 7], 乙: [0, 8], 己: [0, 8],
-    丙: [11, 9], 丁: [11, 9], 辛: [6, 2], 壬: [3, 5], 癸: [3, 5],
-  },
 };
 
 // 截空（按生年干）：single 单星、double 正副双星、zhanyan 占验派
@@ -415,7 +412,12 @@ export function buildZiwei(input) {
   // 紫微按「时辰」起盘：真太阳时若跨时辰/跨日，命盘随之改变
   // 晚子时 next-day：23:00 后起盘日顺延一日，只改起盘日，不改真太阳时显示
   let eff = jdToParts(solar.jd);
-  if (schools.lateZishi === 'next-day' && eff.hour >= 23) eff = jdToParts(solar.jd + 1);
+  if (schools.lateZishi === 'next-day' && eff.hour >= 23) {
+    const shifted = jdToParts(solar.jd + 1);
+    // 晚子时 next-day 若把起盘日推到 2401，同样直接拒绝（直填 2401 本来就被 E_RANGE 拦）
+    assertShifted(shifted, '紫微');
+    eff = shifted;
+  }
   const year = eff.year;
   const month = eff.month;
   const day = eff.day;
@@ -642,7 +644,8 @@ export function buildZiwei(input) {
         branch: BRANCHES[branch],
         palace: palaceNames[branch],
         mutagen: self.mutagen ?? null,
-        sha: stars.filter((s) => s.type === '煞星').map((s) => s.name),
+        // 只有解读词库认的煞星才算「会煞」；full 档新加的天月/阴煞/蜚廉不参与清杂判定
+        sha: stars.filter((s) => s.type === '煞星' && SHA_STAR[s.name]).map((s) => s.name),
       };
     };
     const wc = pick(wenchang, '文昌');
@@ -1308,7 +1311,9 @@ export function enrichLiunian(chart) {
 export function asOfParts(v) {
   if (!v) return null;
   if (typeof v === 'object') return v;
-  const m = String(v).match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[T ](\d{1,2}):(\d{1,2}))?$/);
+  // 首尾空格照 datetime 的规矩 trim 掉：模型输出的 asOf 常带空格，
+  // 以前 ' 2026-10-22 ' 解析不出来，报 E_ASOF 说「请用 2026-10-22T16:00 这种格式」
+  const m = String(v).trim().match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[T ](\d{1,2}):(\d{1,2}))?$/);
   if (!m) return null;
   return {
     year: Number(m[1]), month: Number(m[2]), day: Number(m[3]),