@furongjun1999/dsh-memory 0.6.0 → 0.7.0

package/md_cg/scrub.py

@@ -715,8 +715,8 @@ def decontaminate(cg, node_ids=None, *, kinds=None, dry_run: bool = True,
 # ④ 校准偏差
 # --------------------------------------------------------------------------
 
-# 生效条件：对 cg 中每个「layer 不在 SELF_LAYERS」且 evidence_count≥int(min_evidence)（min_evidence=0 时该比较恒假而不早退）的节点，若 protect.is_protected 为假或 override 为真，且 cg.get(nid) 未抛异常并返回真值节点，则取 fm.get("confidence", 0.6)（缺键才回落 0.6，键存在为 None/假值不回落）为 old，算出 round(max(0.0, min(0.99, old+float(offset))),4)，与 old 差<1e-9 时跳过，否则写 fm["confidence"] 与 fm["calibration"] 并调用 cg._write_node 成功时 adjusted+1（写回异常被吞掉不计数），返回 (adjusted, skipped)，其中 skipped 只累计「layer 属 SELF_LAYERS」或被 protect 拦下且非 override 的节点。
-def _apply_offset(cg, offset, *, override=False, min_evidence=1):
+# 生效条件：对 cg 中每个「layer 不在 SELF_LAYERS」且 evidence_count≥int(min_evidence)（min_evidence=0 时该比较恒假而不早退）的节点，若 protect.is_protected 为假或 override 为真，且 cg.get(nid) 未抛异常并返回真值节点，则先以节点真层/敏感度过 protect.guard_overwrite（层闸 + 保护闸，override 为真时先快照 + 审计，越权抛 AccessDenied 且整批中止），再取 fm.get("confidence", 0.6)（缺键才回落 0.6，键存在为 None/假值不回落）为 old，算出 round(max(0.0, min(0.99, old+float(offset))),4)，与 old 差<1e-9 时跳过，否则写 fm["confidence"] 与 fm["calibration"] 并调用 cg._write_node，成功后置 cg._dirty[nid]=e（**标脏**：推进读缓存代际与索引增量日志）并 adjusted+1（写回异常被吞掉不计数），返回 (adjusted, skipped)，其中 skipped 只累计「layer 属 SELF_LAYERS」或被 protect 拦下且非 override 的节点。
+def _apply_offset(cg, offset, *, override=False, min_evidence=1, actor=None):
     nodes = _nodes(cg)
     adjusted = skipped = 0
     for nid, e in nodes.items():
@@ -736,6 +736,20 @@ def _apply_offset(cg, offset, *, override=False, min_evidence=1):
         if not node:
             continue
         fm = node.get("frontmatter") or {}
+        # N222（2026-09-28，同族未接线写点）：本函数是 calibrate 落库动作，此前
+        # 直调 `cg._write_node` 改写**全库** `layer∉(self,anchor)` 且
+        # `evidence_count≥1` 节点的 confidence/calibration——不过 principal 层写
+        # 白名单、不过引擎级保护闸、`override` 形参直通（含 importance≥0.7 的
+        # 不可遗忘节点），无快照无审计。持 sustain 令牌（`tokens.py:190`
+        # `layers_allow=('self',)`）即可改 knowledge 层节点置信度（实测
+        # `n_adjusted=5`，0.8→0.95；`override=True` 再 +1）。落盘前统一过
+        # `protect.guard_overwrite`：层/敏感度取**节点 fm 真值**（不信索引缓存），
+        # 解析与层闸由 `protect.require_layer` 单点承担，越权即 AccessDenied
+        # 整批中止（fail-closed，不静默跳过——否则越权面被伪装成「无可校准节点」）；
+        # `override=True` 走同一闸的显式放行分支（快照 + `_protected_audit.jsonl`）。
+        protect.guard_overwrite(cg, nid, layer=fm.get("layer"),
+                                sensitivity=fm.get("sensitivity"),
+                                override=override, actor=actor)
         old = float(fm.get("confidence", 0.6))
         new = round(max(0.0, min(0.99, old + float(offset))), 4)
         if abs(new - old) < 1e-9:
@@ -746,6 +760,18 @@ def _apply_offset(cg, offset, *, override=False, min_evidence=1):
         try:
             cg._write_node(nid, os.path.join(cg.root, e["path"]), fm,
                            node.get("content") or "")
+            # 标脏（N133 修复，对照先例 md_cg/mdcg.py 的 update_tags / verify
+            # 直写分支 `self._dirty[node_id] = e`）：本函数原先写盘后**完全不
+            # 碰索引**（条目字段集不含 confidence，无需同步），但正因如此
+            # path_gen 不推进 ⇒ 读缓存（默认开）把写盘前的旧 fm 判新鲜——
+            # 同进程「calibrate 后读」拿旧 confidence（其余两处同族写点
+            # forgetting.reinforce / insight.verify 同批补标脏）。标脏同时
+            # 让本写进 `_dirty → flush → _index_log` 重放。**不下沉进
+            # `_write_node`**：该口另有「只对账索引不落盘」的调用方，下沉会
+            # 凭空产生写入代际与自重载。
+            _dirty = getattr(cg, "_dirty", None)
+            if isinstance(_dirty, dict):
+                _dirty[nid] = e
             adjusted += 1
         except Exception:                                 # noqa: BLE001
             pass
@@ -777,7 +803,8 @@ def calibrate(cg, *, apply: bool = False, override: bool = False, actor=None,
     adjusted = skipped = 0
     if apply and abs(offset) > 1e-9:
         adjusted, skipped = _apply_offset(cg, offset, override=override,
-                                          min_evidence=min_evidence)
+                                          min_evidence=min_evidence,
+                                          actor=actor)
         _log(cg, "calibrate", ok=True, offset=offset, gap=gap,
              adjusted=adjusted, actor=actor)
     blind = 0

package/md_cg/security.py

@@ -382,4 +382,50 @@ def can_read_restricted(p) -> bool:
         return False
     if getattr(p, "can_admin", False):
         return True
-    return getattr(p, "role", "") in _RESTRICTED_READER_ROLES
+    return getattr(p, "role", "") in _RESTRICTED_READER_ROLES
+
+
+# --------------------------------------------------------------------------
+# 读可见性可选钩子（跨层唯一实现，批次 68）
+# --------------------------------------------------------------------------
+# 为什么放在本模块：可见性单点 `_readable` 定义在**子类** `MdCGSecure`
+# （mdcos.py:4028），而需要它的读数出口散在**下层/旁路模块**——trust（验证态
+# 台账/describe）、provenance（派生边端点摘要与拓扑）、evolution（演化账本
+# 自由文本）、forgetting（遗忘留痕 jsonl）。这些模块若 `from .mdcos import` 会
+# 成环（mdcos 反向导入它们），故单点放在两侧都依赖的 security.py：
+#   · `visible_to(cg, entry)`   —— 条目级判定（口径 = `_readable`）；
+#   · `node_visible(cg, node_id)` —— 节点 id 级判定（索引取条目 + 缺席处置）。
+# 口径与仓内既有三处可选钩子逐条一致：`mdcos._note_visible`（及本函数的
+# 委派）、`backfill._readable_guard`、`linkref._known_ids`、`stg._scan/_preview`
+# ——「无钩子（纯 MdCGOS，无身份/密级模型）= 不限制；有钩子 = 按判据；
+# 判据异常 = 不可见（fail-closed）；宁可少读，不可 fail-open 泄漏」。
+# 生效条件：cg 有可调用的 _readable 时返回 bool(判定结果)，判定抛异常返回 False；无该属性/不可调用（纯 MdCGOS）时返回 True。
+def visible_to(cg, entry) -> bool:
+    """条目级读可见性（cg 无 `_readable` 钩子时不设限）。"""
+    fn = getattr(cg, "_readable", None)
+    if not callable(fn):
+        return True
+    try:
+        return bool(fn(entry))
+    except Exception:                          # noqa: BLE001 —— 判据异常=不可见
+        return False
+
+
+# 生效条件：cg 无可调用 _readable 时返回 True；有钩子且索引条目为 dict 时返回 bool(visible_to(cg, 条目))（判定异常 False）；索引无该条目/条目非 dict 时返回 bool(principal.can_admin)（有身份模型但不可证可见→fail-closed，设计者不受限，否则删除后的治理留痕反被清空）。
+def node_visible(cg, node_id) -> bool:
+    """节点 id 级读可见性（索引取条目；**缺席 = 不可证可见 → fail-closed**）。
+
+    缺席的两种实情：① 节点从未存在/拼错 id；② 节点已被 forget（索引无条目）。
+    有身份模型时两者都不得被「当作可见」——否则 `_forgetting.jsonl` /
+    `trust` 台账 / 派生边摘要就成了「已删内容」的旁路读出（N205/N226/N229）。
+    例外只给 can_admin（设计者=全局观测与治理本职）：否则删除后的裁决留痕
+    对唯一需要它的人也不可见（与 `_readable` 的 can_admin 豁免同款）。
+    """
+    fn = getattr(cg, "_readable", None)
+    if not callable(fn):
+        return True                            # 无身份模型：无「越权」可言
+    e = ((getattr(cg, "index", None) or {}).get("nodes") or {}).get(node_id)
+    if isinstance(e, dict):
+        return visible_to(cg, e)
+    p = getattr(cg, "principal", None)
+    return bool(p is not None and getattr(p, "can_admin", False))

package/md_cg/self_state.py

@@ -355,7 +355,7 @@ def _relation_counts(cg, subject):
     slug = _slug(subject)
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
     out = inn = 0
-    for nid, e in nodes.items():
+    for nid, e in list(nodes.items()):
         tags = set(e.get("tags") or [])
         if TAG_RELATION not in tags and not nid.startswith(RELATION_PREFIX):
             continue
@@ -656,7 +656,7 @@ def relations(cg, subject=None, direction="both"):
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
     slug = _slug(subject) if subject else None
     out = []
-    for nid, e in nodes.items():
+    for nid, e in list(nodes.items()):
         tags = set(e.get("tags") or [])
         if TAG_RELATION not in tags and not nid.startswith(RELATION_PREFIX):
             continue
@@ -692,7 +692,7 @@ def index(cg, dim, value, limit=50, with_content=False):
                 "allowed": list(DIMENSIONS)}
     tag = dim_tag(d, value)
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
-    hits = [(nid, e) for nid, e in nodes.items()
+    hits = [(nid, e) for nid, e in list(nodes.items())
             if tag in (e.get("tags") or [])]
     hits.sort(key=lambda kv: (-float(kv[1].get("importance") or 0),
                               -float(kv[1].get("created_at") or 0),
@@ -740,7 +740,7 @@ def audit(cg, subject=DEFAULT_SUBJECT, window=RECENT_WINDOW):
 
     # 1 单例：同 subject 的状态卡只能有一张
     slug = _slug(subject)
-    cards = [n for n, e in nodes.items()
+    cards = [n for n, e in list(nodes.items())
              if TAG_STATE in (e.get("tags") or [])
              and f"state_subject:{slug}" in (e.get("tags") or [])]
     if len(cards) > 1:
@@ -878,7 +878,7 @@ def audit(cg, subject=DEFAULT_SUBJECT, window=RECENT_WINDOW):
             continue
         for v in (vals or []):
             tag = dim_tag(d, v)
-            holders = [n for n, e in nodes.items()
+            holders = [n for n, e in list(nodes.items())
                        if tag in (e.get("tags") or [])]
             if not holders:
                 issues.append(_issue("dimension_orphan", "warn",

package/md_cg/semantic/canonical.py

@@ -31,6 +31,28 @@ from . import zh_en_atoms
 WIN = 6          # 组合共现窗口（token 距离，探针实证口径）
 _ATOMS_ZH = None
 
+# 中文段判据（单点，2026-09-30 检索归一层作用域收窄时立）：
+# 中文 = CJK 统一表意文字基本区 U+4E00–U+9FFF。与 en_normalizer 分词字符类
+# `[A-Za-z\u4e00-\u9fff]` 的中文区间同区间；rust/src/text.rs::is_zh 是同判据的
+# Rust 侧单点（两侧归一层共用同一判据；改动须两侧同步，否则 rank_parity 漂移）。
+# 消费方：unify.py::unify_query（中文段逐字保留）、rust/src/atoms.rs::Atoms::unify。
+ZH_LO, ZH_HI = "\u4e00", "\u9fff"
+
+
+# 生效条件：单参 ch 为长度恰为 1 的 str 时返回 ZH_LO <= ch <= ZH_HI（CJK 基本区）；长度 != 1（空串/多字符串）一律返回 False（2026-09-30 清理批次把边界收紧为「长度恰为 1」——此前只在 ch 为空串时为假，多字符串按字典序比较可能被误判为真）。
+def is_zh_char(ch):
+    """中文段判据（单点）：CJK 统一表意文字基本区 U+4E00–U+9FFF。
+
+    边界约定（2026-09-30 清理批次乙2）：**仅长度恰为 1 的串可为真**——
+    空串与长度 >1 的串一律 False。此前只有空串为假（链式比较
+    `ZH_LO <= ch` 对空串即假），而多字符串按字典序比较：`is_zh_char("中文")`
+    判真（首字符在区间即真）＝判据外溢。两侧调用点清点结果：本函数只有
+    `unify.py::_runs` 与 `test_unify_scope.py::zh_runs` 两处消费，均逐字符
+    传入 ⇒ 本收紧对存量行为零变更；Rust 侧 `text.rs::is_zh` 收 `char`，
+    天然无空/多字符二态，边界语义两侧一致（docstring 已互指）。
+    """
+    return len(ch) == 1 and ZH_LO <= ch <= ZH_HI
+
 
 # 生效条件：模块级常量 `_ATOMS_ZH` 为 None 时按 `__file__` 所在目录的 atoms.json 取 `data.get("atoms", [])` 各项 `zh` 建集合并缓存，非 None 时直接返回 `_ATOMS_ZH`。
 def atoms_zh():

package/md_cg/semantic/unify.py

@@ -1,45 +1,96 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""灵枢 · 检索 query 统一归一层（批次 15，2026-09-23 使用者口径定案）
-
-口径：**统一翻译为中文 → 归一化到标准中文集（atoms.json）→ 检索**。
-任何语言的 query 先归一为标准原子序列（空格 join）再进检索各路：
-  - 英文：en_normalizer（时态还原→停用词剔除→en→zh 语素映射）→
-    segment 展开为标准原子（「牛肉」→「牛 肉」，与 doc 侧 fm.semantic
-    原子形态同构）；
-  - 中文：segment 贪心最长匹配归一到 atoms.json 标准概念；
-  - 纯中文 query **原样返回**——segment+join+bigrams(去空白) 后与原文
-    等价，归一只对跨语 query 有信息增益（beef 与「牛肉」零共享字符，
-    形态归一救不了跨语），纯中文零变更纪律；
+"""灵枢 · 检索 query 统一归一层（批次 15 立；2026-09-30 使用者裁定收窄作用域）
+
+口径：**只对英文内容做翻译归一，中文内容原样不动**。
+query 先按「中文段 / 非中文段」切开，只有**非中文段里的英文**进归一链路：
+  - 非中文段（含 ASCII 字母）：en_normalizer（时态还原→停用词剔除→en→zh 语素
+    映射）→ segment 展开为标准原子（「牛肉」→「牛 肉」，与 doc 侧
+    fm.semantic 原子形态同构）；
+  - 中文段（CJK 统一表意文字基本区 U+4E00–U+9FFF，判据单点 =
+    `canonical.is_zh_char`）：**逐字保留、绝不切分、绝不送 segment**；
+  - 非英文段（数字/标点等，段内无 ASCII 字母）：原样保留（不是英文即不翻译）；
+  - 两段按原顺序以单空格 join，空白（段内/段间）一律折叠为单空格；
   - 专名/未登录词原样保留（词表边界 unknown_keep，非错误）。
 
-开关：MDCG_UNIFY_QUERY 默认 "1"（2026-09-23 使用者拍板口径转正）；
-"=0" 显式关回退。两侧同步：rust/mcdg-eval 读同一 env + 同一份
-atoms.json（scripts/rank_parity.py --dataset 对拍在两侧同开关态进行，
-A/B 差异归档为转正证据）。
+为什么收窄（2026-09-30 定因，实测于 locomo-zh-500 公开题池 500 题 / 567 池、
+eval_common jaccard + GLOBAL_CAP 解除、k=5）：旧口径「query 含任一 ASCII 字母
+即整条归一」会把**中夹英** query 的中文部分逐字切开（「自我接纳」→
+「自 我 接 纳」、「慈善跑」→「慈 善 跑」）；500 题里含 ASCII 字母的 145 条
+**全部**也含中文（无纯英文 query）。单点实测：整条归一 lexical hit@1 = 94.4% /
+lexical,fuzzy = 87.2%；只译英文片段 lexical = 95.8% / lexical,fuzzy = 96.6%；
+归一层全关 lexical = 96.4% / lexical,fuzzy = 97.2%。
+
+开关：MDCG_UNIFY_QUERY **默认关**（2026-09-30 使用者裁定，缺省由 "1" 翻为 "0"）。
+定因：本层本职是让**英文** query 命中中文节点，对中文检索池是**纯开销**——
+locomo-zh-500 公开题池（池 567 / 题 500）缺省关态 lexical hit@1 96.4% /
+lexical+fuzzy 97.2%，开态 95.8% / 96.6%（各跑两遍逐位相同）。
+
+三态判据（两侧同语义，唯一开态 = 显式 "1"）：
+
+    MDCG_UNIFY_QUERY      Python unify_on()   Rust Atoms::from_env()
+    未设                   False               None（不载入）
+    "0"                    False               None（不载入）
+    "1"                    True                Some(Atoms)（载入）
+
+显式 "1" 仍能开回（英文对照路要用）；两侧同源 en_zh_map.json
+（scripts/rank_parity.py --dataset 对拍在两侧同开关态进行）。
 
 归一失败（semantic 模块缺失等）静默原样返回——与 en_zh_terms 同降级
 风格，不阻断检索主链路。
+
+两侧同构：rust/src/atoms.rs::Atoms::unify 同语义、同中文判据；逐位对拍 fixture
+= `md_cg/semantic/unify_fixture.json`（本侧守卫 md_cg/test_unify_scope.py 与
+Rust 单测 unify_mixed_fixture_matches_python 钉同一份期望值）。
 """
 import os
 import re
 
-# 生效条件：无 required 形参，锚定环境变量名 MDCG_UNIFY_QUERY；当 os.environ.get("MDCG_UNIFY_QUERY", "1") == "1" 时返回 True，否则返回 False。
+from .canonical import is_zh_char
+
+# 生效条件：无 required 形参，锚定环境变量名 MDCG_UNIFY_QUERY；**未设**时取缺省 "0"（2026-09-30 使用者裁定：缺省关），当 os.environ.get("MDCG_UNIFY_QUERY", "0") == "1" 时返回 True，其余（未设 / "0" / 任何非 "1" 取值）返回 False。
 def unify_on() -> bool:
-    """统一归一层开关（默认开=口径定案转正；=0 显式关回退）。"""
-    return os.environ.get("MDCG_UNIFY_QUERY", "1") == "1"
+    """统一归一层开关（**默认关**；显式 =1 才开，=0/未设一律关）。"""
+    return os.environ.get("MDCG_UNIFY_QUERY", "0") == "1"
+
+
+# 生效条件：单参 text 为任意字符串（空串返回空列表），按 canonical.is_zh_char 逐字符判中文段，相邻同判据字符归并为一个连续段，返回 [(是否中文段, 段文本), ...] 的保序列表。
+def _runs(text):
+    """按中文判据切连续段：[(True, "中文段"), (False, "非中文段"), ...]。"""
+    out = []
+    cur = None
+    buf = []
+    for ch in text:
+        k = is_zh_char(ch)
+        if buf and k != cur:
+            out.append((cur, "".join(buf)))
+            buf = []
+        cur = k
+        buf.append(ch)
+    if buf:
+        out.append((cur, "".join(buf)))
+    return out
 
 
-# 生效条件：text 为 None/空串或开关关闭或不含 [A-Za-z] 时原样返回；否则经 canonical.query_atoms 归一为标准原子序列并以单空格 join 返回（归一产物为空或抛异常时原样返回）。
+# 生效条件：text 为 None/空串、或开关 MDCG_UNIFY_QUERY 取值不为 "1"（含**未设**——缺省 "0"，2026-09-30 起关）、或 strip 后不含 [A-Za-z] 时，原样返回 text（未 strip 的入参）；否则按中文段（canonical.is_zh_char）切分——中文段与不含 ASCII 字母的非中文段逐字保留、含 ASCII 字母的非中文段经 canonical.query_atoms 归一——各段折空白后按原顺序单空格 join；归一产物为空（trim 后）或抛异常时原样返回 text。
 def unify_query(text):
-    """检索入口统一归一：任意语言 query → 标准原子序列。"""
+    """检索入口统一归一：只译英文内容，中文段逐字原样。"""
     t = (text or "").strip()
     if not t or not unify_on() or not re.search(r"[A-Za-z]", t):
         return text
     try:
         from .canonical import query_atoms
-        atoms = query_atoms(t)
+        parts = []
+        for is_zh, run in _runs(t):
+            if is_zh or not re.search(r"[A-Za-z]", run):
+                seg = run                       # 中文段 / 非英文段：逐字保留
+            else:
+                atoms = query_atoms(run)        # 非中文段里的英文：既有链路
+                seg = " ".join(a for a in atoms if a)
+            seg = " ".join(seg.split())         # 段内空白折叠为单空格
+            if seg:
+                parts.append(seg)
     except Exception:
         return text
-    u = " ".join(a for a in atoms if a).strip()
+    u = " ".join(parts)
     return u if u else text

package/md_cg/semantic/unify_fixture.json

@@ -0,0 +1,25 @@
+{
+  "_note": "统一归一层（unify_query / Atoms::unify）作用域收窄（2026-09-30 使用者裁定：只对英文内容做翻译归一，中文内容原样不动）的逐位对拍 fixture。两侧同源钉死：Python 守卫 md_cg/test_unify_scope.py 与 Rust 单测 rust/src/atoms.rs::tests::unify_mixed_fixture_matches_python 都读本文件（Rust 侧 include_str! 编译期嵌入）。任一侧实现漂移即红。含「空产物回退」例（入参含首尾空白且归一产物为空 → 两侧逐位回退**原入参本身**，2026-09-30 清理批次乙1 钉住；Python 侧语义为 unify_query 尾行 `return text`）。",
+  "_caveat": "非中文段一律用「两侧处理同构」的形态：全小写英文词（或命中 en_zh_map 的形）。两侧**既有非对称**共三条（非 2026-09-30 收窄引入，亦非本清理批次引入——HEAD 对照实测同分歧），故不入本 fixture：①未登录大写英文词——Python 保留原 case（`领养 LGBTQ 群体`→原样、`AI 记忆 系统`→原样），Rust 经 normalize_en 一律 lower（→`领养 lgbtq 群体`/`ai 记忆 系统`）；②命中词表的专名——Python 双原子保留原词+译词（`Paris 报告`→`Paris 巴 黎 报告`），Rust 只出译词（→`巴 黎 报告`）；③字母与数字同段——Python 丢数字（`beef 2024 报告`→`牛肉 报告`），Rust 保数字（→`牛肉 2024 报告`）。**真源 = `docs/hive/检索算法口径对照_v0.1.md` 正文「两侧既有非对称」表**（含两侧原始读数、fixture 为何避开、以及「统一到哪一侧」的待裁定项）；本文件只钉两侧同构形态。",
+  "cases": [
+    {"name": "纯英·跨语归一冒烟", "in": "I eat beef yesterday", "out": "我 吃 牛肉 昨天"},
+    {"name": "纯英·单动词时态还原", "in": "wrote", "out": "写"},
+    {"name": "纯英·多词", "in": "compiler tests", "out": "编 辑 家 测 试"},
+    {"name": "纯中·复合词不切", "in": "自我接纳", "out": "自我接纳"},
+    {"name": "纯中·旧口径会切开的两字三字词", "in": "慈善跑", "out": "慈善跑"},
+    {"name": "纯中·带空格", "in": "蜂群调度 依赖门禁", "out": "蜂群调度 依赖门禁"},
+    {"name": "中夹英·英文在首", "in": "beef 报告", "out": "牛肉 报告"},
+    {"name": "中夹英·未登录英文片段+中文段逐字保留", "in": "领养 xyzzy 群体", "out": "领养 xyzzy 群体"},
+    {"name": "英夹中·英文译中文段原样", "in": "beef 牛肉", "out": "牛肉 牛肉"},
+    {"name": "前后空白·折叠", "in": "  beef 报告  ", "out": "牛肉 报告"},
+    {"name": "空产物回退·原样返回原入参（不 trim）", "in": "  the is  ", "out": "  the is  "},
+    {"name": "多空格·折叠为单空格", "in": "beef   报告", "out": "牛肉 报告"},
+    {"name": "数字·非英文段原样", "in": "2024 报告", "out": "2024 报告"},
+    {"name": "数字+中文+英文混合", "in": "2024 年 beef 报告", "out": "2024 年 牛肉 报告"},
+    {"name": "半角标点·非英文段原样", "in": "beef 阅读,写作", "out": "牛肉 阅读 , 写作"},
+    {"name": "全角标点·非英文段原样", "in": "报告。很好 beef", "out": "报告 。 很好 牛肉"},
+    {"name": "未登录词·unknown_keep", "in": "xyzzy 报告", "out": "xyzzy 报告"},
+    {"name": "单字母词 I", "in": "I 支持", "out": "我 支持"},
+    {"name": "英中粘连·无空格混合", "in": "beef报告", "out": "牛肉 报告"}
+  ]
+}