fix: 3 silent-wrong bugs found by adversarial audit + value tests (v1.1.5)

- tarot (HIGH): asset {major,minor} dict never loaded (isinstance list check) ->
  every reading used placeholder text. Add _flatten_asset_deck; real meanings now.
- huangli 吉时/凶时 (HIGH): classified by "has any 宜" -> always 12吉/0凶. Now use
  时辰黄道/黑道 (getTimeTianShenLuck) for a real split. Drop dead getTimes/getTimeXun.
- ziwei 真太阳时 (HIGH): --tz/--longitude accepted but ignored. Wire through
  longitude_correction, opt-in (only non-default longitude/tz) so default
  时辰-granular charts are unchanged.
- zodiac (LOW): same-sign pair mis-flagged 三合; require distinct branches.
- +5 tests (94->99): value goldens (紫微/奇门/六壬), regression locks (tarot asset,
  huangli split, ziwei opt-in, same-sign), kill meihua tautology.

Author: ShousenZHANG

CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes follow [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) format. This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.5] — 2026-05-31
+
+Bug-fix release — three silent-wrong defects found by an adversarial line-by-line
+audit, plus value-level test coverage to lock them.
+
+### Fixed
+- **塔罗 (HIGH)** — `tarot_draw.load_deck` gated on `isinstance(deck, list)`, but
+  the asset ships as `{major_arcana, minor_arcana}` (dict), so the curated 78-card
+  deck **never loaded** and every reading silently used placeholder text
+  ("…第N阶: 见详细解读"). Added `_flatten_asset_deck`; readings now carry the real
+  per-card 正/逆位 meanings.
+- **黄历 吉时/凶时 (HIGH)** — classification used "时辰 has any 宜", which is true for
+  all 12, so output was always 12 吉 / 0 凶 (meaningless). Now derived from the
+  时辰 黄道/黑道 (`getTimeTianShenLuck`): a real 吉/凶 split. Removed dead
+  `getTimes()` / `getTimeXun()` calls.
+- **紫微 真太阳时 (HIGH)** — `--tz`/`--longitude` were accepted but ignored, so a
+  user-supplied longitude produced an uncorrected chart (silent-wrong near 子时).
+  Now wired through `longitude_correction` (with day roll-over) — **opt-in**: only
+  applied when a non-default longitude/tz is given, so 时辰-granular charts on the
+  default meridian are unchanged (no regression).
+- **生肖 (LOW)** — same-sign pairs (e.g. 鼠-鼠) were mis-flagged 三合 because
+  `da in group and db in group` is true when `da == db`. Now requires distinct
+  branches.
+
+### Added
+- +5 tests (suite 94 → 99): value-golden assertions for 紫微 命宫/身宫/局,
+  奇门 阳遁8局, 大六壬 丙午日; regression locks for the tarot asset, huangli 黄黑道
+  吉凶 split, ziwei longitude opt-in, same-sign 三合; replaced a tautological
+  meihua `relation` truthy-check with a valid-relation assertion.
+
 ## [1.1.4] — 2026-05-31
 
 Continuous integration — closes the last engineering gap found in a 4-repo

scripts/bazi_calc.py

@@ -49,7 +49,7 @@
 )
 
 
-VERSION = "1.1.4"
+VERSION = "1.1.5"
 ASSETS_DIR = Path(__file__).resolve().parents[1] / "assets"
 
 

scripts/huangli_query.py

@@ -34,44 +34,29 @@ def _safe_method(obj, name: str, default=None):
 
 
 def _hour_pillars(lunar) -> list[dict]:
-    """For each of the 12 双小时, return ganzhi + ji/xiong markers."""
-    out: list[dict] = []
-    try:
-        shichen_list = lunar.getTimes()
-        # Some versions: getShichenJiXiong / getTimeJiXiong.
-    except Exception:
-        shichen_list = []
+    """For each of the 12 双小时, return ganzhi + 黄黑道 吉凶 markers.
 
-    # Fallback: build 12 time entries by iterating over hour 0..23 step 2
+    吉凶 comes from the hour's 天神 黄道/黑道 (getTimeTianShenLuck), NOT from
+    whether the hour has any 宜 — every 时辰 has non-empty 宜, so the latter
+    would mark all 12 as 吉.
+    """
+    out: list[dict] = []
     try:
         from lunar_python import Solar  # type: ignore
         solar = lunar.getSolar()
         for hour_pair in range(0, 24, 2):
-            # 子时归当日 (sect=2). Use middle of the 2-hour window for safety.
-            h = hour_pair if hour_pair != 23 else 23
             s = Solar.fromYmdHms(solar.getYear(), solar.getMonth(),
-                                 solar.getDay(), h, 30, 0)
+                                 solar.getDay(), hour_pair, 30, 0)
             lh = s.getLunar()
-            time_in_gz = lh.getTimeInGanZhi()
-            # ji or xiong
-            try:
-                jx = lh.getTimeXun()  # not exactly ji/xiong but provides 旬
-            except Exception:
-                jx = None
-            try:
-                yixion = lh.getTimeYi()
-                ji = lh.getTimeJi()
-                chong_sha = lh.getTimeChongDesc()
-            except Exception:
-                yixion = []
-                ji = []
-                chong_sha = None
             out.append({
-                "hour_range": f"{hour_pair:02d}:00-{(hour_pair+2)%24:02d}:00",
-                "ganzhi": time_in_gz,
-                "yi": yixion,
-                "ji": ji,
-                "chong_sha": chong_sha,
+                "hour_range": f"{hour_pair:02d}:00-{(hour_pair + 2) % 24:02d}:00",
+                "ganzhi": lh.getTimeInGanZhi(),
+                "tian_shen": _safe_method(lh, "getTimeTianShen", None),
+                "huang_hei_dao": _safe_method(lh, "getTimeTianShenType", None),
+                "luck": _safe_method(lh, "getTimeTianShenLuck", None),
+                "yi": _safe_method(lh, "getTimeYi", []),
+                "ji": _safe_method(lh, "getTimeJi", []),
+                "chong_sha": _safe_method(lh, "getTimeChongDesc", None),
             })
     except Exception as e:
         warn(f"hour pillars failed: {e}")
@@ -128,10 +113,10 @@ def main(argv: Optional[list[str]] = None) -> int:
     peng_zu_gan = _safe_method(lunar, "getPengZuGan", None)
     peng_zu_zhi = _safe_method(lunar, "getPengZuZhi", None)
 
-    # 今日吉时/凶时
+    # 今日吉时/凶时 — 按 时辰黄黑道吉凶 (黄道=吉, 黑道=凶), 非"有无宜事"
     ji_xiong_shichen = _hour_pillars(lunar)
-    ji_shi = [s for s in ji_xiong_shichen if s.get("yi")]
-    xiong_shi = [s for s in ji_xiong_shichen if not s.get("yi") and s.get("ji")]
+    ji_shi = [s for s in ji_xiong_shichen if s.get("luck") == "吉"]
+    xiong_shi = [s for s in ji_xiong_shichen if s.get("luck") == "凶"]
 
     # Nearest jieqi
     jieqi_now = _safe(lunar.getJieQi, None)

scripts/tarot_draw.py

@@ -123,6 +123,54 @@ def build_full_deck() -> list[dict]:
     return deck
 
 
+# Suit metadata for flattening the {major_arcana, minor_arcana} asset shape.
+_ASSET_SUITS: dict[str, dict[str, str]] = {
+    "wands": {"zh": "权杖", "en": "Wands", "element": "火", "domain": "事业/行动"},
+    "cups": {"zh": "圣杯", "en": "Cups", "element": "水", "domain": "情感/关系"},
+    "swords": {"zh": "宝剑", "en": "Swords", "element": "风", "domain": "思想/冲突"},
+    "pentacles": {"zh": "星币", "en": "Pentacles", "element": "土", "domain": "物质/财务"},
+}
+_RANK_NUM: dict[str, int] = {
+    "Ace": 1, "Page": 11, "Knight": 12, "Queen": 13, "King": 14,
+}
+
+
+def _flatten_asset_deck(data: dict) -> list[dict]:
+    """Convert the {major_arcana:[...], minor_arcana:{suit:[...]}} asset into
+    the flat card schema used by draw_cards. Returns [] on shape mismatch so
+    the caller can fall back to the embedded deck."""
+    major = data.get("major_arcana")
+    minor = data.get("minor_arcana")
+    if not isinstance(major, list) or not isinstance(minor, dict):
+        return []
+    deck: list[dict] = []
+    for m in major:
+        deck.append({
+            "arcana": "major",
+            "number": m.get("number"),
+            "en": m.get("name_en"), "zh": m.get("name_zh"),
+            "suit": None, "element": m.get("element"),
+            "keywords_up": "、".join(m.get("keywords_upright", [])) or m.get("upright_meaning", ""),
+            "keywords_rev": "、".join(m.get("keywords_reversed", [])) or m.get("reversed_meaning", ""),
+        })
+    for suit_key, cards in minor.items():
+        meta = _ASSET_SUITS.get(suit_key, {"zh": suit_key, "en": suit_key,
+                                           "element": None, "domain": ""})
+        for c in cards:
+            rank = str(c.get("rank", ""))
+            deck.append({
+                "arcana": "minor",
+                "number": _RANK_NUM.get(rank, int(rank) if rank.isdigit() else 0),
+                "en": f"{rank} of {meta['en']}",
+                "zh": c.get("name_zh"),
+                "suit": meta["zh"], "suit_en": meta["en"],
+                "element": meta["element"], "domain": meta["domain"],
+                "keywords_up": c.get("upright", ""),
+                "keywords_rev": c.get("reversed", ""),
+            })
+    return deck
+
+
 def load_deck() -> list[dict]:
     here = os.path.dirname(os.path.abspath(__file__))
     candidates = [
@@ -133,9 +181,17 @@ def load_deck() -> list[dict]:
     if asset:
         try:
             with open(asset, "r", encoding="utf-8") as f:
-                deck = json.load(f)
-            if isinstance(deck, list) and len(deck) >= 22:
+                raw = json.load(f)
+            # Asset ships as {major_arcana, minor_arcana}; flatten it.
+            if isinstance(raw, dict):
+                deck = _flatten_asset_deck(raw)
+            elif isinstance(raw, list):
+                deck = raw
+            else:
+                deck = []
+            if len(deck) >= 78:
                 return deck
+            warn(f"tarot78.json yielded {len(deck)} cards (<78); using embedded deck")
         except Exception as e:
             warn(f"failed to load tarot78.json: {e}")
     return build_full_deck()

scripts/ziwei_calc.py

@@ -38,12 +38,13 @@
     WUHU_DUN,
     jiazi_index,
     json_print,
+    longitude_correction,
     require_lunar,
     warn,
 )
 
 
-VERSION = "1.1.4"
+VERSION = "1.1.5"
 
 
 # --------------------------------------------------------------------------- #
@@ -853,14 +854,40 @@ def main(argv: Optional[list[str]] = None) -> int:
         })
         return 1
 
+    # 真太阳时校正 — 仅当用户显式提供非默认经度/时区时应用。
+    # 紫微输入通常是粗粒度时辰; 默认经度(120)/时区(8) 表示"未提供精确出生地",
+    # 此时保留所输入时辰原样, 避免 EOT 把临界时辰(如 01:00)误推过 时辰边界。
+    # 给出真实经度即视为有精确出生地, 按 bazi 同法校正(近子时可滚日)。
+    tst_applied = False
+    birth_hour = args.hour
+    if args.longitude != 120.0 or args.tz != 8.0:
+        try:
+            day_off, corr_hour, corr_minute = longitude_correction(
+                args.hour, args.minute, args.longitude, args.tz,
+                year=solar.getYear(), month=solar.getMonth(), day=solar.getDay(),
+            )
+            if (day_off, corr_hour, corr_minute) != (0, args.hour, args.minute):
+                from datetime import date, timedelta
+                base = date(solar.getYear(), solar.getMonth(), solar.getDay())
+                if day_off:
+                    base = base + timedelta(days=day_off)
+                solar = Solar.fromYmdHms(base.year, base.month, base.day,
+                                         corr_hour, corr_minute, 0)
+                lunar = solar.getLunar()
+            birth_hour = corr_hour
+            tst_applied = True
+        except Exception as exc:
+            warn(f"true_solar_time correction skipped: {exc}")
+            birth_hour = args.hour
+
     year_stem = lunar.getYearGan()
     year_branch = lunar.getYearZhi()
     lunar_month = abs(lunar.getMonth())
     lunar_day = lunar.getDay()
 
     # 1. 命宫 / 身宫 / 宫干.
-    mg_branch = calc_ming_gong(lunar_month, args.hour)
-    sg_branch = calc_shen_gong(lunar_month, args.hour)
+    mg_branch = calc_ming_gong(lunar_month, birth_hour)
+    sg_branch = calc_shen_gong(lunar_month, birth_hour)
     mg_stem = stem_of_palace(year_stem, mg_branch)
 
     # 2. 五行局.
@@ -871,14 +898,14 @@ def main(argv: Optional[list[str]] = None) -> int:
     main_pos = place_main_stars(zw_branch)
 
     # 4. 六吉 + 六煞 + 杂曜.
-    lucky_pos = place_lucky_stars(year_stem, lunar_month, args.hour)
-    malefic_pos = place_malefic_stars(year_stem, year_branch, args.hour)
+    lucky_pos = place_lucky_stars(year_stem, lunar_month, birth_hour)
+    malefic_pos = place_malefic_stars(year_stem, year_branch, birth_hour)
     misc_pos = place_miscellaneous_stars(year_branch)
 
     # 5. 命主 / 身主 / 斗君.
     ming_zhu = MING_ZHU.get(year_branch, "?")
     shen_zhu = SHEN_ZHU.get(year_branch, "?")
-    dou_jun_branch = calc_dou_jun(lunar_month, args.hour)
+    dou_jun_branch = calc_dou_jun(lunar_month, birth_hour)
 
     # 6. 反向索引 — branch -> list of stars by category.
     branch_to_main: dict[str, list[str]] = {b: [] for b in DIZHI}

scripts/zodiac_compat.py

@@ -176,7 +176,8 @@ def compat(a: str, b: str) -> dict:
         score += 4
     in_sanhe = False
     for group in SAN_HE_GROUPS:
-        if da in group and db in group:
+        # 三合需两个 *不同* 地支同组; 同生肖(da==db)是比和/自刑, 非三合。
+        if da != db and da in group and db in group:
             relations.append("三合")
             score += 3
             in_sanhe = True

tests/test_engines.py

@@ -66,8 +66,10 @@ def test_meihua_structure():
     d = run("meihua_cast.py", "numbers", "--upper", "3", "--lower", "5", "--question", "x")
     has(d, "main_hex", "changed_hex", "nuclear_hex", "ti_yong")
     assert 1 <= d["main_hex"]["number"] <= 64
-    # body/use relation must be one of the 5 五行 relations
-    assert d["ti_yong"]["relation"]
+    # body/use relation must be one of the 5 五行 relations (not just truthy).
+    rel = d["ti_yong"]["relation"]
+    assert any(rel.startswith(r) for r in
+               ("体生用", "用生体", "体克用", "用克体", "比和")), rel
 
 
 # --------------------------------------------------------------------------- #
@@ -94,6 +96,26 @@ def test_xiaoliuren_structure():
     assert d["result"]["tone"] in {"吉", "凶", "中"}
 
 
+# --------------------------------------------------------------------------- #
+# 塔罗 — REGRESSION: the curated 78-card asset must actually load (the dict-vs-
+# list check used to discard it, silently degrading to placeholder text).
+# --------------------------------------------------------------------------- #
+
+def test_tarot_loads_real_asset_not_placeholder():
+    d = run("tarot_draw.py", "three", "--seed", "42", "--question", "x")
+    assert len(d["cards"]) == 3
+    for c in d["cards"]:
+        assert c["card_name_zh"]
+        assert c["meaning_brief"]
+        # The degraded fallback emits "...第N阶: 见详细解读"; real asset never does.
+        assert "见详细解读" not in c["meaning_brief"]
+
+def test_tarot_seed_reproducible():
+    a = run("tarot_draw.py", "celtic", "--seed", "7", "--question", "x")
+    b = run("tarot_draw.py", "celtic", "--seed", "7", "--question", "x")
+    assert [c["card_name_zh"] for c in a["cards"]] == [c["card_name_zh"] for c in b["cards"]]
+
+
 # --------------------------------------------------------------------------- #
 # 生肖合婚 — deterministic; 虎申 must be 相冲 (score low)
 # --------------------------------------------------------------------------- #
@@ -109,6 +131,11 @@ def test_zodiac_compat_sanhe_high():
     d = run("zodiac_compat.py", "compat", "--a", "虎", "--b", "马")
     assert d["score"] >= 6
 
+def test_zodiac_same_sign_not_sanhe():
+    # 同生肖(鼠-鼠)是比和/自刑, 不能误判为三合 (子∈申子辰).
+    d = run("zodiac_compat.py", "compat", "--a", "鼠", "--b", "鼠")
+    assert "三合" not in d["relations"]
+
 
 # --------------------------------------------------------------------------- #
 # 奇门遁甲 — deterministic by date/time
@@ -121,6 +148,8 @@ def test_qimen_structure():
     has(d, "ju_type", "ju_number", "ganzhi")
     assert d["ju_type"] in {"阳遁", "阴遁"}
     assert 1 <= d["ju_number"] <= 9
+    # Value golden — 芒种前 阳遁, this date/time resolves to 阳遁 8局.
+    assert (d["ju_type"], d["ju_number"]) == ("阳遁", 8)
 
 
 # --------------------------------------------------------------------------- #
@@ -132,6 +161,8 @@ def test_liuren_structure():
     d = run("liuren_cast.py", "--date", "2026-06-01", "--time", "14:30", "--question", "x")
     assert d["ok"] is True
     has(d, "ri_gan", "ri_zhi", "month_zhi")
+    # Value golden — 2026-06-01 is 丙午 day, 占时 within 巳 month-general window.
+    assert (d["ri_gan"], d["ri_zhi"]) == ("丙", "午")
 
 
 # --------------------------------------------------------------------------- #
@@ -146,6 +177,35 @@ def test_huangli_structure():
     assert isinstance(d["ji"], list)
 
 
+@needs_lunar
+def test_huangli_jishi_uses_huangdao_not_all12():
+    """REGRESSION: 吉时/凶时 must come from 时辰黄黑道 (吉/凶), not "has any 宜".
+    The old logic marked all 12 时辰 吉 and 0 凶."""
+    d = run("huangli_query.py", "--date", "2026-06-01")
+    ji, xiong = d["ji_shi"], d["xiong_shi"]
+    assert len(ji) + len(xiong) == 12          # every 时辰 classified
+    assert 0 < len(ji) < 12                     # not all-吉 (the bug)
+    assert len(xiong) > 0                       # 凶时 exist
+    assert all(s.get("luck") == "吉" for s in ji)
+    assert all(s.get("huang_hei_dao") == "黄道" for s in ji)
+
+
+@needs_lunar
+def test_ziwei_value_golden_and_longitude_optin():
+    """ziwei standard chart value golden + longitude correction is opt-in
+    (default longitude must NOT shift the 时辰-granular chart)."""
+    d = run("ziwei_calc.py", "--year", "1995", "--month", "7", "--day", "20",
+            "--hour", "1", "--gender", "female", "--lunar")
+    assert (d["ming_gong"]["branch"], d["shen_gong"]["branch"],
+            d["wuxing_ju"]["name"]) == ("未", "酉", "木三局")
+    # Explicit far-west longitude near midnight DOES correct (different 命宫).
+    near = run("ziwei_calc.py", "--year", "2000", "--month", "6", "--day", "15",
+               "--hour", "23", "--minute", "30", "--gender", "male")
+    west = run("ziwei_calc.py", "--year", "2000", "--month", "6", "--day", "15",
+               "--hour", "23", "--minute", "30", "--longitude", "75", "--gender", "male")
+    assert near["ming_gong"]["branch"] != west["ming_gong"]["branch"]
+
+
 # --------------------------------------------------------------------------- #
 # 紫微斗数 — structure of the hand-rolled engine
 # --------------------------------------------------------------------------- #