@furongjun1999/dsh-memory 0.4.11 → 0.5.0

package/md_cg/statushdr.py

@@ -1,179 +1,179 @@
-# -*- coding: utf-8 -*-
-"""md_cg · 状态摘要协议（MCP 输出面一等公民）
-
-【为什么】验证态若只在 frontmatter / 索引里躺着，读面就得「先知道去哪查」——
-与纪律只存在于认知图时执行率近零同构。故把状态**推进每一次返回体**：
-人类与 agent 读面一致，默认开启。
-
-四符号（`HEAD_MARKS`）：
-    ✓ 已验证   证据在位、依赖未动、时效内
-    △ 已修改   复核中（上游动过，复核进行态）
-    ! 异常     已过期（时效失效）或依赖目标悬空——**地基动了**
-    ? 存疑     依赖变动后被自动标记，待复核
-（未验证补 `·`：不是四态之一，但读面需要一个「尚未验证」的可视锚点。）
-
-【怎么做】在 `_cg_call` **单一出口**统一挂 `status_head` 并升级既有 `hint`——
-29+ 个 op 分支一处不改，爆炸半径最小。注入仅对返回体中**实际出现的节点 id**
-计算（O(k)，受 `k` 与 MAX_IDS 约束），不做全库扫描。
-
-【关闭】`MDCG_STATUS_HEAD=0` 回退旧 hint 文本（灰度/排障用）。
-
-零第三方依赖（D-005）。
-"""
-from __future__ import annotations
-
-import os
-
-from . import trust
-
-#: 四符号（读面契约，勿随意改字形——agent 侧提示词按此对齐）
-MARK_VERIFIED = "✓"
-MARK_MODIFIED = "△"
-MARK_ABNORMAL = "!"
-MARK_DOUBTED = "?"
-MARK_UNVERIFIED = "·"
-HEAD_MARKS = (MARK_VERIFIED, MARK_MODIFIED, MARK_ABNORMAL, MARK_DOUBTED)
-
-ENV = "MDCG_STATUS_HEAD"
-#: 注入上限：单次返回体最多为这么多节点计算状态头（防大结果集拖慢出口）
-MAX_IDS = 50
-
-
-def enabled() -> bool:
-    """状态头开关（默认开启；`MDCG_STATUS_HEAD=0` 回退旧 hint 文本）。"""
-    v = (os.environ.get(ENV) or "").strip().lower()
-    return v not in ("0", "false", "no", "off")
-
-
-def _mark(state: str, valid_kind: str, dangling: bool) -> str:
-    if dangling or valid_kind == "expired" or state == "expired":
-        return MARK_ABNORMAL
-    if state == "doubted":
-        return MARK_DOUBTED
-    if state == "rechecking":
-        return MARK_MODIFIED
-    if state == "verified":
-        return MARK_VERIFIED
-    return MARK_UNVERIFIED
-
-
-def _label(mark: str) -> str:
-    return {MARK_VERIFIED: "已验证", MARK_MODIFIED: "已修改",
-            MARK_ABNORMAL: "异常", MARK_DOUBTED: "存疑",
-            MARK_UNVERIFIED: "未验证"}.get(mark, "未验证")
-
-
-def render(cg, node_id: str, *, node: dict = None, index_entry: dict = None,
-           now: float = None) -> str:
-    """单条状态头字符串（附方式 / 时间 / 影响范围 / 待确认条件）。只读不抛。"""
-    try:
-        e = index_entry
-        if e is None:
-            e = ((getattr(cg, "index", None) or {}).get("nodes") or {}).get(node_id)
-        fm = (node or {}).get("frontmatter") if node else None
-        if fm is None:
-            fm = e or {}
-        state = trust.state_of(fm)
-        kind, _s, _e = trust.validity(fm, now=now)
-        deps = trust.as_deps(fm.get(trust.DEPS_FIELD))
-        known = set((getattr(cg, "index", None) or {}).get("nodes") or {})
-        dangling = [p for p in deps if p not in known]
-        mark = _mark(state, kind, bool(dangling))
-        bits = []
-        if dangling:
-            bits.append(f"依赖目标缺失：{','.join(dangling[:3])}")
-        if kind == "expired":
-            bits.append("时效已过")
-        elif kind == "not_yet":
-            bits.append("尚未生效")
-        method = (fm.get("verification_method") or fm.get("verification_basis")
-                  or "")
-        if method and mark == MARK_VERIFIED:
-            bits.append(f"方式={str(method)[:40]}")
-        if mark == MARK_DOUBTED:
-            bits.append("上游变动，待复核")
-        if mark in (MARK_VERIFIED, MARK_MODIFIED) and fm.get("verified_at"):
-            try:
-                import time as _t
-                bits.append("验证于 " + _t.strftime(
-                    "%Y-%m-%d", _t.localtime(float(fm["verified_at"]))))
-            except Exception:                              # noqa: BLE001
-                pass
-        return f"{mark} {_label(mark)}" + (f"（{'；'.join(bits)}）" if bits else "")
-    except Exception as exc:                               # noqa: BLE001
-        return f"{MARK_UNVERIFIED} 未验证（状态头降级：{type(exc).__name__}）"
-
-
-#: 返回体中可能承载节点 id 的键（显式枚举，避免把任意字符串误当 id）
-_ID_KEYS = ("node_id", "id", "nid")
-
-
-def _collect_ids(obj, acc: list, depth: int = 0) -> None:
-    """递归收集候选节点 id（深度/数量双上限；找不到就不找，绝不猜）。"""
-    if len(acc) >= MAX_IDS or depth > 4:
-        return
-    if isinstance(obj, dict):
-        for k, v in obj.items():
-            if k in _ID_KEYS and isinstance(v, str) and v:
-                acc.append(v)
-            elif isinstance(v, (dict, list)):
-                _collect_ids(v, acc, depth + 1)
-                if len(acc) >= MAX_IDS:
-                    return
-    elif isinstance(obj, list):
-        for it in obj:
-            _collect_ids(it, acc, depth + 1)
-            if len(acc) >= MAX_IDS:
-                return
-
-
-def attach_heads(cg, out: dict, *, now: float = None) -> dict:
-    """扫描返回体中的节点 id，批量挂 `status_head`（O(k)，幂等）。"""
-    if not isinstance(out, dict):
-        return out
-    ids, seen = [], set()
-    _collect_ids(out, ids)
-    known = (getattr(cg, "index", None) or {}).get("nodes") or {}
-    heads = {}
-    for nid in ids:
-        if nid in seen or nid not in known:
-            continue
-        seen.add(nid)
-        heads[nid] = render(cg, nid, index_entry=known.get(nid), now=now)
-    if not heads:
-        return out
-    out["status_heads"] = heads
-    out["status_head"] = (next(iter(heads.values())) if len(heads) == 1
-                          else f"{len(heads)} 节点（见 status_heads）")
-    return out
-
-
-def annotate(cg, out: dict, *, now: float = None) -> dict:
-    """**单出口**注入口：挂状态头 + 把既有 `hint` 升级为状态头格式。
-
-    幂等：已注入过（`status_head` 在返回体中）则不再重复改写 hint。
-    """
-    if not enabled() or not isinstance(out, dict):
-        return out
-    if "status_head" in out:
-        return out
-    before_hint = out.get("hint")
-    attach_heads(cg, out, now=now)
-    head = out.get("status_head")
-    if head and before_hint:
-        out["hint"] = f"{head} · {before_hint}"
-    elif head:
-        out["hint"] = head
-    return out
-
-
-def catalog() -> dict:
-    """自描述（供 MCP catalog / 人工核对）。"""
-    return {
-        "layer": "状态摘要协议",
-        "marks": {"verified": MARK_VERIFIED, "modified": MARK_MODIFIED,
-                  "abnormal": MARK_ABNORMAL, "doubted": MARK_DOUBTED,
-                  "unverified": MARK_UNVERIFIED},
-        "env": ENV, "default_on": True, "max_ids": MAX_IDS,
-        "note": "统一在 _cg_call 单出口注入；hint 同步升级（Q3 默认开启）",
-    }
+# -*- coding: utf-8 -*-
+"""md_cg · 状态摘要协议（MCP 输出面一等公民）
+
+【为什么】验证态若只在 frontmatter / 索引里躺着，读面就得「先知道去哪查」——
+与纪律只存在于认知图时执行率近零同构。故把状态**推进每一次返回体**：
+人类与 agent 读面一致，默认开启。
+
+四符号（`HEAD_MARKS`）：
+    ✓ 已验证   证据在位、依赖未动、时效内
+    △ 已修改   复核中（上游动过，复核进行态）
+    ! 异常     已过期（时效失效）或依赖目标悬空——**地基动了**
+    ? 存疑     依赖变动后被自动标记，待复核
+（未验证补 `·`：不是四态之一，但读面需要一个「尚未验证」的可视锚点。）
+
+【怎么做】在 `_cg_call` **单一出口**统一挂 `status_head` 并升级既有 `hint`——
+29+ 个 op 分支一处不改，爆炸半径最小。注入仅对返回体中**实际出现的节点 id**
+计算（O(k)，受 `k` 与 MAX_IDS 约束），不做全库扫描。
+
+【关闭】`MDCG_STATUS_HEAD=0` 回退旧 hint 文本（灰度/排障用）。
+
+零第三方依赖（D-005）。
+"""
+from __future__ import annotations
+
+import os
+
+from . import trust
+
+#: 四符号（读面契约，勿随意改字形——agent 侧提示词按此对齐）
+MARK_VERIFIED = "✓"
+MARK_MODIFIED = "△"
+MARK_ABNORMAL = "!"
+MARK_DOUBTED = "?"
+MARK_UNVERIFIED = "·"
+HEAD_MARKS = (MARK_VERIFIED, MARK_MODIFIED, MARK_ABNORMAL, MARK_DOUBTED)
+
+ENV = "MDCG_STATUS_HEAD"
+#: 注入上限：单次返回体最多为这么多节点计算状态头（防大结果集拖慢出口）
+MAX_IDS = 50
+
+
+def enabled() -> bool:
+    """状态头开关（默认开启；`MDCG_STATUS_HEAD=0` 回退旧 hint 文本）。"""
+    v = (os.environ.get(ENV) or "").strip().lower()
+    return v not in ("0", "false", "no", "off")
+
+
+def _mark(state: str, valid_kind: str, dangling: bool) -> str:
+    if dangling or valid_kind == "expired" or state == "expired":
+        return MARK_ABNORMAL
+    if state == "doubted":
+        return MARK_DOUBTED
+    if state == "rechecking":
+        return MARK_MODIFIED
+    if state == "verified":
+        return MARK_VERIFIED
+    return MARK_UNVERIFIED
+
+
+def _label(mark: str) -> str:
+    return {MARK_VERIFIED: "已验证", MARK_MODIFIED: "已修改",
+            MARK_ABNORMAL: "异常", MARK_DOUBTED: "存疑",
+            MARK_UNVERIFIED: "未验证"}.get(mark, "未验证")
+
+
+def render(cg, node_id: str, *, node: dict = None, index_entry: dict = None,
+           now: float = None) -> str:
+    """单条状态头字符串（附方式 / 时间 / 影响范围 / 待确认条件）。只读不抛。"""
+    try:
+        e = index_entry
+        if e is None:
+            e = ((getattr(cg, "index", None) or {}).get("nodes") or {}).get(node_id)
+        fm = (node or {}).get("frontmatter") if node else None
+        if fm is None:
+            fm = e or {}
+        state = trust.state_of(fm)
+        kind, _s, _e = trust.validity(fm, now=now)
+        deps = trust.as_deps(fm.get(trust.DEPS_FIELD))
+        known = set((getattr(cg, "index", None) or {}).get("nodes") or {})
+        dangling = [p for p in deps if p not in known]
+        mark = _mark(state, kind, bool(dangling))
+        bits = []
+        if dangling:
+            bits.append(f"依赖目标缺失：{','.join(dangling[:3])}")
+        if kind == "expired":
+            bits.append("时效已过")
+        elif kind == "not_yet":
+            bits.append("尚未生效")
+        method = (fm.get("verification_method") or fm.get("verification_basis")
+                  or "")
+        if method and mark == MARK_VERIFIED:
+            bits.append(f"方式={str(method)[:40]}")
+        if mark == MARK_DOUBTED:
+            bits.append("上游变动，待复核")
+        if mark in (MARK_VERIFIED, MARK_MODIFIED) and fm.get("verified_at"):
+            try:
+                import time as _t
+                bits.append("验证于 " + _t.strftime(
+                    "%Y-%m-%d", _t.localtime(float(fm["verified_at"]))))
+            except Exception:                              # noqa: BLE001
+                pass
+        return f"{mark} {_label(mark)}" + (f"（{'；'.join(bits)}）" if bits else "")
+    except Exception as exc:                               # noqa: BLE001
+        return f"{MARK_UNVERIFIED} 未验证（状态头降级：{type(exc).__name__}）"
+
+
+#: 返回体中可能承载节点 id 的键（显式枚举，避免把任意字符串误当 id）
+_ID_KEYS = ("node_id", "id", "nid")
+
+
+def _collect_ids(obj, acc: list, depth: int = 0) -> None:
+    """递归收集候选节点 id（深度/数量双上限；找不到就不找，绝不猜）。"""
+    if len(acc) >= MAX_IDS or depth > 4:
+        return
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            if k in _ID_KEYS and isinstance(v, str) and v:
+                acc.append(v)
+            elif isinstance(v, (dict, list)):
+                _collect_ids(v, acc, depth + 1)
+                if len(acc) >= MAX_IDS:
+                    return
+    elif isinstance(obj, list):
+        for it in obj:
+            _collect_ids(it, acc, depth + 1)
+            if len(acc) >= MAX_IDS:
+                return
+
+
+def attach_heads(cg, out: dict, *, now: float = None) -> dict:
+    """扫描返回体中的节点 id，批量挂 `status_head`（O(k)，幂等）。"""
+    if not isinstance(out, dict):
+        return out
+    ids, seen = [], set()
+    _collect_ids(out, ids)
+    known = (getattr(cg, "index", None) or {}).get("nodes") or {}
+    heads = {}
+    for nid in ids:
+        if nid in seen or nid not in known:
+            continue
+        seen.add(nid)
+        heads[nid] = render(cg, nid, index_entry=known.get(nid), now=now)
+    if not heads:
+        return out
+    out["status_heads"] = heads
+    out["status_head"] = (next(iter(heads.values())) if len(heads) == 1
+                          else f"{len(heads)} 节点（见 status_heads）")
+    return out
+
+
+def annotate(cg, out: dict, *, now: float = None) -> dict:
+    """**单出口**注入口：挂状态头 + 把既有 `hint` 升级为状态头格式。
+
+    幂等：已注入过（`status_head` 在返回体中）则不再重复改写 hint。
+    """
+    if not enabled() or not isinstance(out, dict):
+        return out
+    if "status_head" in out:
+        return out
+    before_hint = out.get("hint")
+    attach_heads(cg, out, now=now)
+    head = out.get("status_head")
+    if head and before_hint:
+        out["hint"] = f"{head} · {before_hint}"
+    elif head:
+        out["hint"] = head
+    return out
+
+
+def catalog() -> dict:
+    """自描述（供 MCP catalog / 人工核对）。"""
+    return {
+        "layer": "状态摘要协议",
+        "marks": {"verified": MARK_VERIFIED, "modified": MARK_MODIFIED,
+                  "abnormal": MARK_ABNORMAL, "doubted": MARK_DOUBTED,
+                  "unverified": MARK_UNVERIFIED},
+        "env": ENV, "default_on": True, "max_ids": MAX_IDS,
+        "note": "统一在 _cg_call 单出口注入；hint 同步升级（Q3 默认开启）",
+    }

package/md_cg/stg.py

@@ -25,11 +25,11 @@ PLACEHOLDER_LOCKED = "[密文·预览已脱敏]"
 PLACEHOLDER_DENIED = "[无权限·预览已脱敏]"
 
 
-# 生效条件：time_axis 经 trust.time_axis_of 归一（None → observed，非法轴如 believed 抛 ValueError）；observed 轴下 fm 的 temporal 非 None 且 float(t) 可成功时返回 (float(t), float(t))，temporal 缺失/为 None/转换抛 TypeError 或 ValueError 时回退到 fm["condition_space"]（假值按 {} 处理）的 time_window，仅当其为长度 2 的 list/tuple 且两元素可 float 时返回 (float(tw[0]), float(tw[1]))，否则返回 None；effective 轴下取 trust.time_window_of(fm, "effective") 的两端点，两端均可解析才返回 (float(s), float(e))，任一端缺失或不可解析返回 None。
+# 生效条件：time_axis 经 trust.time_axis_of 归一（None → observed，非法轴如 believed 抛 ValueError）；随后**完全委托** trust.time_window_of(fm, 该轴) 取两端点，两端均可解析才返回 (float(s), float(e))，任一端缺失或不可解析返回 None。
 def _interval(fm, time_axis="observed"):
-    """节点时间区间；轴语义与 `trust.time_window_of` **同源**（唯一口径，不新写解析）。
+    """节点时间区间；**单一口径**——直接委托 `trust.time_window_of`，不新写解析。
 
-    · `observed`（默认，与旧行为**逐位一致**）：优先 `temporal`（事件时刻），
+    · `observed`（默认，合法秒值上与旧行为逐位一致）：优先 `temporal`（事件时刻），
       回退 `condition_space.time_window`（观测窗）。
       注意 add() 在调用方未给 time_window 时会以「写入时刻」自动填充；
       若把它当事件时间，两条不同时刻的节点会得到假的重叠关系，故 temporal 优先。
@@ -38,27 +38,17 @@ def _interval(fm, time_axis="observed"):
       区间语义要求**两端齐备**——单侧缺失/不可解析 → `None`（不可判定，
       不猜测边界：给半开区间补 `±inf` 会让 `time_relation` 报出假的 contains/during）。
 
+    **单位归一**单点落在 `trust.parse_time` → `trust.epoch_seconds`（issue #23）：
+    旧实现在观察轴分支自己写了一份 `float(tw[0])` 裸转、**绕开了归一**，于是历史
+    毫秒节点在这里拿到 1.7e12 的 `start`，把 timeline 头部占满并顶掉 auto-recall。
+    委托后两个轴共用同一份取值与归一实现，不会再出现「一个轴修了、另一个轴没修」。
+
     `believed_at` **永不参与任何轴**（同 `trust.BELIEVED_FIELD` 的隔离纪律）。
     """
-    if trust.time_axis_of(time_axis) == "effective":
-        s, e = trust.time_window_of(fm, "effective")
-        if s is None or e is None:
-            return None
-        return (float(s), float(e))
-    t = fm.get("temporal")
-    if t is not None:
-        try:
-            return (float(t), float(t))
-        except (TypeError, ValueError):
-            pass
-    cs = fm.get("condition_space") or {}
-    tw = cs.get("time_window")
-    if isinstance(tw, (list, tuple)) and len(tw) == 2:
-        try:
-            return (float(tw[0]), float(tw[1]))
-        except (TypeError, ValueError):
-            return None
-    return None
+    s, e = trust.time_window_of(fm, trust.time_axis_of(time_axis))
+    if s is None or e is None:
+        return None
+    return (float(s), float(e))
 
 
 # 生效条件：fm["spatial"]（假值按 {} 处理）为 dict 且其 bbox 是长度 4 的 list/tuple 且四元素可 float 时返回浮点四元组，spatial 非 dict、bbox 非长度 4 序列或元素转换抛 TypeError/ValueError 时返回 None。
@@ -141,6 +131,9 @@ def _scan(cg, layer=None, max_scan=5000):
             # 路径上永远「不可判定」（静默全空，比报错更难查）。旧索引快照无这些
             # 键时 `.get` 得 None → 不可判定，是本轴**如实降级**而非误判。
             fm = {"temporal": e.get("temporal"), "spatial": e.get("spatial"),
+                  # 会话归属必须一并从快照带出：timeline 的会话过滤与归属回带都
+                  # 走这条快照路径，缺键 → 本会话视图静默全空（比报错更难查）。
+                  "session": e.get("session"),
                   trust.EFFECTIVE_FROM_FIELD: e.get(trust.EFFECTIVE_FROM_FIELD),
                   trust.EFFECTIVE_UNTIL_FIELD: e.get(trust.EFFECTIVE_UNTIL_FIELD),
                   trust.FROM_FIELD: e.get(trust.FROM_FIELD),
@@ -211,21 +204,37 @@ def relation(cg, a_id, b_id, time_axis="observed"):
                      "space_known": ba is not None and bb is not None}}
 
 
-# 生效条件：以 _scan(cg,layer=layer,max_scan=max_scan) 为范围，_interval(n["frontmatter"], time_axis) 为 None 的节点被跳过，其余按 (start,end) 以 reverse=bool(desc) 排序，返回 count=全部命中数、limit=传入 limit、items 为排序后前 limit 项（limit=0 时为空列表）且每项附 _preview(cg,id)（time_axis 缺省 observed，与旧行为逐位一致；非法轴抛 ValueError）。
+# 生效条件：以 _scan(cg,layer=layer,max_scan=max_scan) 为范围，session 去空白后非空且不为 "*" 时仅保留 frontmatter.session 精确相等的节点，_interval(n["frontmatter"], time_axis) 为 None 的节点被跳过，其余按 (start,end) 以 reverse=bool(desc) 排序，返回 count=全部命中数、limit=传入 limit、session=生效的会话过滤值（跨会话时为 None）、items 为排序后前 limit 项（limit=0 时为空列表）且每项附 session 归属与 _preview(cg,id)（time_axis 缺省 observed，与旧行为逐位一致；非法轴抛 ValueError）。
 def timeline(cg, layer=None, limit=50, desc=True, max_scan=5000,
-             time_axis="observed"):
-    """按时间排序的节点列表。`time_axis` 决定排序依据的时间区间（见 `_interval`）。"""
+             time_axis="observed", session=None):
+    """按时间排序的节点列表。`time_axis` 决定排序依据的时间区间（见 `_interval`）。
+
+    `session` 是**视图开关**（P45 归因维度，与授权正交）：
+      · 缺省 None / 空串 → 不过滤：一次读遍所有会话（向后兼容，旧调用方多如此）；
+      · `"*"` → 同上语义，但把「我要看所有会话做了什么」写成**显式意图**，与
+        「忘了传参」区分开，审计里也看得出这是一次跨会话读取；
+      · 其它值 → 只取 `frontmatter.session` 精确相等的节点（本会话视图，
+        自动召回用它防串台）。
+    `items` 一并回带 `session`：跨会话视图下「这条是哪个会话做的」必须可辨，
+    否则「能读到所有会话做了什么」只剩内容、丢了归属。
+    """
+    sid = "" if session is None else str(session).strip()
+    cross = sid in ("", "*")            # 跨会话：显式 "*" 与缺省同义
     items = []
     for n in _scan(cg, layer=layer, max_scan=max_scan):
-        iv = _interval(n["frontmatter"], time_axis)
+        fm = n["frontmatter"] or {}
+        if not cross and fm.get("session") != sid:
+            continue
+        iv = _interval(fm, time_axis)
         if iv is None:
             continue
-        items.append((iv[0], iv[1], n["id"], n["layer"]))
+        items.append((iv[0], iv[1], n["id"], n["layer"], fm.get("session")))
     items.sort(key=lambda x: (x[0], x[1], x[2]), reverse=bool(desc))
     return {"count": len(items), "limit": limit,
+            "session": None if cross else sid,
             "items": [{"id": i, "layer": l, "start": s, "end": e,
-                       "preview": _preview(cg, i)}
-                      for s, e, i, l in items[:limit]]}
+                       "session": sn, "preview": _preview(cg, i)}
+                      for s, e, i, l, sn in items[:limit]]}
 
 
 # 生效条件：time_window 为长度 2 的 list/tuple 时 q_t=(float(time_window[0]),float(time_window[1]))（元素不可转 float 会直接抛异常，源码未捕获），bbox 为长度 4 的 list/tuple 时同理构造 q_b；q_t 与 q_b 均为 None 时返回 {"error":"need_time_window_or_bbox"}；否则扫描节点、每节点时间区间按 _interval(fm, time_axis) 取（time_axis 缺省 observed 与旧行为逐位一致，非法轴抛 ValueError），并要求时间关系在 during/contains/overlaps/equals、空间关系在 inside/contains/overlaps/equals（提供查询侧才检查），返回 hits[:limit]（limit=None 取全部，0/False 取空）；
@@ -259,13 +268,17 @@ def anchors(cg, time_window=None, bbox=None, layer=None, limit=50, max_scan=5000
             "items": hits[:limit]}
 
 
-# 生效条件：遍历 _scan(cg,layer=layer,max_scan=max_scan) 每条 frontmatter，bb 非 None 且不满足 bb[0]<=bb[2] and bb[1]<=bb[3] 记 invalid_bbox、iv（由 _interval(fm, time_axis) 取，time_axis 缺省 observed 与旧行为逐位一致、非法轴抛 ValueError）非 None 且 iv[0]>iv[1] 记 inverted_time_window、temporal 非 None 且 time_window 为长度 2 的 list/tuple 且 float 比较成功却不满足 tw[0]<=t<=tw[1] 记 temporal_outside_window（该检查恒按观察轴内部口径、不随 time_axis 漂移；转换抛 TypeError/ValueError 则忽略），返回 scanned 计数、issues 总数与 issues[:limit]（limit 默认 50）。
+# 生效条件：遍历 _scan(cg,layer=layer,max_scan=max_scan) 每条 frontmatter，bb 非 None 且不满足 bb[0]<=bb[2] and bb[1]<=bb[3] 记 invalid_bbox、iv（由 _interval(fm, time_axis) 取，time_axis 缺省 observed 与旧行为逐位一致、非法轴抛 ValueError）非 None 且 iv[0]>iv[1] 记 inverted_time_window、temporal 与 time_window 均经 trust.epoch_seconds 归一后可比且不满足 tw[0]<=t<=tw[1] 记 temporal_outside_window（该检查恒按观察轴内部口径、不随 time_axis 漂移；任一端不可转数值则忽略），返回 scanned 计数、issues 总数与 issues[:limit]（limit 默认 50）。
 def consistency(cg, layer=None, limit=50, max_scan=5000, time_axis="observed"):
     """时空字段自洽性检查：非法 bbox / 时间倒置 / 窗口与时刻冲突。
 
     `time_axis` 只决定「时间倒置」按哪条轴判；`temporal_outside_window`
     恒按**观察轴内部**口径（temporal 与 time_window 的关系）——那是该 issue 的
     定义本身，换轴会让它变成另一件事（不随参数漂移）。
+
+    两端比较前统一经 `trust.epoch_seconds` 归一：旧实现裸 `float` 比较，历史毫秒
+    节点的 `1.7e12` 与秒级 `temporal` 永不落入区间 → 该检查在真实库中**静默失效**
+    （issue #23 同根因）。返回体的 `temporal` / `time_window` 也随之为归一后的秒值。
     """
     issues = []
     scanned = 0
@@ -277,15 +290,13 @@ def consistency(cg, layer=None, limit=50, max_scan=5000, time_axis="observed"):
             issues.append({"id": n["id"], "issue": "invalid_bbox", "bbox": bb})
         if iv and iv[0] > iv[1]:
             issues.append({"id": n["id"], "issue": "inverted_time_window", "time": iv})
-        t = fm.get("temporal")
+        t = trust.epoch_seconds(fm.get("temporal"))
         cs = fm.get("condition_space") or {}
         tw = cs.get("time_window")
         if t is not None and isinstance(tw, (list, tuple)) and len(tw) == 2:
-            try:
-                if not (float(tw[0]) <= float(t) <= float(tw[1])):
-                    issues.append({"id": n["id"], "issue": "temporal_outside_window",
-                                   "temporal": t, "time_window": [tw[0], tw[1]]})
-            except (TypeError, ValueError):
-                pass
+            lo, hi = trust.epoch_seconds(tw[0]), trust.epoch_seconds(tw[1])
+            if lo is not None and hi is not None and not (lo <= t <= hi):
+                issues.append({"id": n["id"], "issue": "temporal_outside_window",
+                               "temporal": t, "time_window": [lo, hi]})
     return {"scanned": scanned, "issues": len(issues), "limit": limit,
             "items": issues[:limit]}