@furongjun1999/dsh-memory 0.4.10 → 0.4.11

package/md_cg/whitebox_kb/wisdom/docs//344/273/243/347/240/201/350/257/255/344/271/211/346/235/241/344/273/266/345/215/217/350/256/256.md

@@ -403,9 +403,9 @@ L4  终层           全层无法判断 → BLINDSPOT（escalation_trace 记录
 能力边界；全层耗尽才宣告盲区——**盲区不是第一层的失败，而是所有层的
 共同结论**（与人类认知层级同构：直觉 → 领域知识 → 跨域推理 → 承认无知）。
 
-## 14. Kimi 评审映射（智能论 v3.3 条件论同构性 + 三风险落地）
+## 14. Kimi 评审映射（智能论 v3.4 条件论同构性 + 三风险落地）
 
-**评审结论**：注释规范与智能论 v3.3 条件论（附录11）高度同构——功能条件
+**评审结论**：注释规范与智能论 v3.4 条件论（附录11）高度同构——功能条件
 =条件空间声明、子功能=任意分层性、子功能/执行=信息差缩小路径、不适用
 条件=盲区标记；条件路由图 = 可执行的条件空间切换机制（解决盲区13
 过滤与映射规则来源盲区）。

package/md_cg/whitebox_kb/wisdom/docs//345/261/200/351/203/250/346/234/200/344/274/230/344/270/216/346/203/205/347/273/252/345/201/217/345/245/275_/347/220/206/350/256/272/345/267/245/347/250/213.md

@@ -1,6 +1,6 @@
 # 局部最优 × 情绪方向性偏好 · 理论理解与工程应用（2026-09）
 
-## 一、理论理解（智能论 v3.3）
+## 一、理论理解（智能论 v3.4）
 
 ### 1. 局部最优合法化（PROP-LOCAL-OPTIMUM-005）
 

package/md_cg/whitebox_kb/wisdom/docs//347/201/265/346/236/242AGI/346/236/266/346/236/204/346/216/242/347/264/242_/346/226/207/346/241/243/350/247/204/345/210/222.md

@@ -5,7 +5,7 @@
 **分类名**：AGI 架构探索（AGI Architecture Exploration）
 **定位**：不是「智能体架构」——那是工程框架（多 agent 编排/工具调用）。
 灵枢是**架构探索**：在真实 DSH 环境中复现业界公认的 AGI 核心功能，
-每一项都有工程实现 + 理论条款（智能论 v3.3）映射 + 可验证指标。
+每一项都有工程实现 + 理论条款（智能论 v3.4）映射 + 可验证指标。
 
 ## 二、灵枢能力 ↔ AGI 核心功能映射表
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进 md_cg 认知图（md 文档）",
   "type": "module",
   "main": "lib/index.js",
@@ -76,10 +76,10 @@
     "typescript": "^5.5.0"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "test": "npm run build && node --import tsx --test \"test/*.test.ts\"",
-    "prepare": "node -e \"const fs=require('fs');const tsc='node_modules/typescript/bin/tsc';fs.existsSync(tsc)?require('child_process').execFileSync(process.execPath,[tsc,'-p','tsconfig.json'],{stdio:'inherit'}):console.log('[prepare] 跳过构建：typescript 未安装（NODE_ENV=production 或 --omit=dev 会省略 devDependencies）——需要构建请用 npm install --include=dev')\"",
-    "prepublishOnly": "npm run build && npm test"
+    "prepare": "node -e \"const fs=require('fs');const tsc='node_modules/typescript/bin/tsc';fs.existsSync(tsc)?(fs.rmSync('lib',{recursive:true,force:true}),require('child_process').execFileSync(process.execPath,[tsc,'-p','tsconfig.json'],{stdio:'inherit'})):console.log('[prepare] 跳过构建：typescript 未安装（NODE_ENV=production 或 --omit=dev 会省略 devDependencies）——需要构建请用 npm install --include=dev')\"",
+    "prepublishOnly": "npm run build && npm test && python scripts/check_publish_artifact.py"
   },
   "repository": {
     "type": "git",

package/src/bridge.ts

@@ -12,6 +12,9 @@ import { createInterface } from 'node:readline'
 import { mkdirSync, appendFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { homedir } from 'node:os'
+// issue #19：自检命令文案按平台给出（Windows python / 其它 python3）、
+// 并在 ENOENT 时把「解释器名不匹配」这一第一因直接写进日志。
+import { explainMissingPython, selfCheckCommand } from './lib/python_path.js'
 
 /**
  * 调试探针：记录桥生命周期到独立文件（绕过 DSH 日志系统，便于定位启动问题）。
@@ -203,6 +206,12 @@ export class LingshuBridge {
       // 进程无法启动（python 不存在等）——响亮失败
       if (!this.disposed) {
         console.error(`[lingshu-bridge] 灵枢进程启动失败: ${err.message}`)
+        // issue #19：ENOENT 的第一因通常不是「环境损坏」，而是解释器名与平台不匹配
+        // （Linux/macOS 按 PEP 394 只有 python3）。把成因与修法写进同一条日志——
+        // 原始日志把该缺陷伪装成「调用超时」，用户按超时方向排查只会白耗一轮。
+        if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+          console.error(`[lingshu-bridge] ${explainMissingPython(python)}`)
+        }
         probe(`spawn error: ${String(err)}`)
         this.readyState = 'failed'
         this.flushBootQueue(false)
@@ -230,8 +239,8 @@ export class LingshuBridge {
         this.unexpectedExits.push(Date.now())
         if (uptimeS >= 0 && uptimeS < 5) {
           console.error(
-            '[lingshu-bridge] 进程启动后 5 秒内即退出——请检查 python 可执行文件与 md_cg 依赖。' +
-            '自检 `python -m md_cg.mcp_server` 须在插件包根目录运行' +
+            `[lingshu-bridge] 进程启动后 5 秒内即退出——请检查 ${python} 可执行文件与 md_cg 依赖。` +
+            `自检 \`${selfCheckCommand(python)}\` 须在插件包根目录运行` +
             '（插件已自动锚定 cwd 与 PYTHONPATH，issue #12）。')
         } else if (this.unexpectedExits.length >= 3) {
           console.error(
@@ -292,7 +301,8 @@ export class LingshuBridge {
       this.flushBootQueue(false)
       console.error(
         `[lingshu-bridge] 连续启动失败 ${this.retries} 次，已停止自动重启（不再后台空转）。` +
-        '请检查 python 可执行文件与 md_cg 依赖；自检 `python -m md_cg.mcp_server` 须在插件包根目录运行' +
+        `请检查 ${this.options.python} 可执行文件与 md_cg 依赖；` +
+        `自检 \`${selfCheckCommand(this.options.python)}\` 须在插件包根目录运行` +
         '（插件已自动锚定 cwd 与 PYTHONPATH，issue #12），修复后在 DSH 中重新启用 dsh-memory 插件。')
       probe(`give up: ${this.retries} consecutive failures, entering failed terminal state`)
       return
@@ -322,7 +332,9 @@ export class LingshuBridge {
     if (this.gaveUp) {
       return Promise.reject(new Error(
         '灵枢进程不可用：连续启动失败已达上限，已停止重试。' +
-        '请检查 python 可执行文件与 md_cg 依赖（自检 `python -m md_cg.mcp_server` 须在插件包根目录运行），修复后重新启用 dsh-memory 插件。'))
+        `请检查 ${this.options.python} 可执行文件与 md_cg 依赖` +
+        `（自检 \`${selfCheckCommand(this.options.python)}\` 须在插件包根目录运行），` +
+        '修复后重新启用 dsh-memory 插件。'))
     }
     const id = this.nextId++
     const timeout = this.options.timeoutMs

package/src/index.ts

@@ -54,6 +54,9 @@ import { installMemoryHooks, type MemoryHooksOptions } from './hooks.js'
 // LIB 本地库：角色扮演网页 / 互维维护 / 白箱 LLM 适配器统一收在 src/lib/。
 import { installRoleplayWeb } from './lib/roleplay_web.js'
 import { MdcgClient } from './lib/mdcg_client.js'
+// 解释器解析（issue #19）：默认值按平台取（Windows: python / 其它: python3），
+// 可用 env MDCG_PYTHON 覆盖；此前写死 'python' 使 Linux/macOS 首装即挂。
+import { defaultPython, selfCheckCommand } from './lib/python_path.js'
 import { describeDataPaths, migrateLegacyData, mdcgRoot, repoRoot } from './lib/datapath.js'
 // 写入凭据密钥环（首启引导）：显式配置 → ~/.mdcg/token → 首启自动签发。
 import { resolveToken, type TokenResolution } from './lib/token_store.js'
@@ -92,7 +95,9 @@ export const inject = ['tools']
 export interface Config {
   /** 工具命名空间前缀（默认 lingshu → lingshu_remember）。 */
   serverName: string
-  /** Python 可执行文件（或 md_cg-mcp console script）。 */
+  /** Python 可执行文件（或 md_cg-mcp console script）。
+   *  缺省 = 平台感知（issue #19）：Windows `python` / Linux·macOS `python3`，
+   *  可用 env `MDCG_PYTHON` 覆盖；显式配置本项优先级最高。 */
   python: string
   /** 传给 python 的参数（默认启动 md_cg MCP server）。 */
   moduleArgs: string[]
@@ -144,7 +149,10 @@ export interface Config {
 
 export const Config: z<Config> = z.object({
   serverName: z.string().default('lingshu'),
-  python: z.string().default('python'),
+  // issue #19：默认值按平台解析（Windows: python / 其它: python3；env MDCG_PYTHON 可覆盖）。
+  // 写死 'python' 时 Linux/macOS 首装即 spawn ENOENT（PEP 394 只有 python3），
+  // 且表现为「装好了但记忆永远为空」——最难定位的失效形态。
+  python: z.string().default(defaultPython()),
   moduleArgs: z.array(String).default(['-m', 'md_cg.mcp_server']),
   dbPath: z.string().default('data/lingshu.db'),
   identity: z.string().default('灵枢'),
@@ -327,7 +335,9 @@ export async function apply(ctx: Context, config: Config): Promise<void> {
   /** 大脑桥：工具面 + 互维 + 角色落图共用的唯一 md_cg 通道（mdcg 关闭时为 null）。 */
   const bridge = mdcg?.bridge ?? null
   if (!brainReady) {
-    const message = '灵枢大脑（md_cg）未就绪（检查 python 是否可用、md_cg 是否可导入：python -m md_cg.mcp_server）'
+    // issue #19：自检命令按当前解释器给出（Windows python / 其它 python3），
+    // 照抄报错里的命令在用户平台上必须真的可执行。
+    const message = `灵枢大脑（md_cg）未就绪（检查 ${config.python} 是否可用、md_cg 是否可导入：${selfCheckCommand(config.python)}）`
     if (config.failOnStartupError && config.mdcg.enabled) {
       // P1 修复（GPT 审查）：启动失败抛错前必须 dispose——此前 throw 在 try 之前，
       // 桥接对象泄漏 + 后台重试计时器继续跑

package/src/lib/mutual.ts

@@ -16,6 +16,9 @@ import * as fs from 'node:fs'
 import * as path from 'node:path'
 import * as os from 'node:os'
 import { pythonPathValue, runRoot } from './datapath.js'
+// issue #19：解释器默认值按平台解析（Windows: python / 其它: python3；
+// env MDCG_PYTHON 可覆盖）。此前写死 'python'，Linux/macOS 上 mutual 一开就撞 ENOENT。
+import { defaultPython } from './python_path.js'
 
 export interface MutualOptions {
   /** 心跳间隔（毫秒），默认 10min */
@@ -90,7 +93,10 @@ export function judgeStamp(stamp: { ageMs: number; task_running: boolean } | nul
 // 守护 A（检测 harness 进程 + 拉起）
 // ---------------------------------------------------------------------------
 
-const HARNESS_PROC = ['python', 'harness.guardian']  // wmic 特征
+// 进程探测特征 = 命令行含 'harness.guardian' / 'harness.main'（见 harnessRunning）。
+// issue #19 已知边界（未纳入本轮修复面）：Windows 分支按 name='python.exe' 过滤，
+// 用其它可执行名（conda 的 python3.exe 等）启动的 harness 可能漏检；该路径由
+// config.mutual.enabled 控制（默认关）。
 
 function execP(cmd: string): Promise<string> {
   return new Promise((resolve) => {
@@ -120,7 +126,7 @@ export async function harnessRunning(): Promise<boolean> {
 }
 
 /** detached 拉起 A 侧 harness.guardian（幂等：先确认不存在） */
-export async function ensureHarness(python = 'python',
+export async function ensureHarness(python = defaultPython(),
                                     opts: MutualOptions = DEFAULTS): Promise<'started' | 'already' | 'failed'> {
   const running = await harnessRunning()
   if (running) return 'already'
@@ -146,7 +152,18 @@ export async function ensureHarness(python = 'python',
         // 同 mdcg_client：cwd 必须在包外（否则 pnpm 更新时 rmdir 包目录被 Windows
         // 拒绝 → ERR_PNPM_EBUSY）；模块解析由 PYTHONPATH 保证，见 datapath.runRoot()。
         cwd: runRoot(),
-        env: { ...process.env, PYTHONPATH: pythonPathValue() },
+        // 两条编码注入与 mdcg_client.mdcgChildEnv() 同口径（2026-09-20 v15-9）：
+        // 本站点此前只给 PYTHONPATH，是「唯一构造点」主张下**未表态**的 Python 站点
+        // （v15b 结构扫描：Python 目标 3 站点、走构造点 0 个、两条编码变量全缺 2 个）。
+        // 此处**不引** mdcgChildEnv()：它构造的是 md_cg 子进程环境（带 MDCG_ROOT /
+        // MDCG_MCP_SURFACE / MDCG_MCP_* 等，对 harness.guardian 无意义）；只对齐编码口径。
+        // 站点表态由 test/python-utf8-mode.test.ts ④（站点扫描）机械守护。
+        env: {
+          ...process.env,
+          PYTHONPATH: pythonPathValue(),
+          PYTHONUTF8: '1',
+          PYTHONIOENCODING: 'utf-8',
+        },
       })
     } catch (e) {
       log(opts, `守护失败：${String(e)}`)
@@ -370,7 +387,7 @@ export function installMutualMaintenance(
     try {
       writeHeartbeat(opts)
       // 守护 A：harness 不在 → 拉起
-      ensureHarness('python', opts).then((r) => {
+      ensureHarness(defaultPython(), opts).then((r) => {
         if (r === 'started') ctx.logger.info(`mutual: 已拉起 A 侧 harness（${r}）`)
       })
       // 读 A 戳分级判定

package/src/lib/python_path.ts

@@ -0,0 +1,71 @@
+/**
+ * python_path.ts —— Python 解释器的**平台感知**解析（issue #19）
+ *
+ * 要解决的问题（首次安装即失效，且不自愈）
+ * ------------------------------------------------
+ * 解释器默认值此前是**字面量 `'python'`**。Linux/macOS 按 PEP 394 只要求提供
+ * `python3`——发行版默认状态就是这样，不是用户把环境装坏了。于是 `spawn('python')`
+ * 抛 `ENOENT`，桥重试 8 次后进入 failed 终态：插件看起来装好了，工具不注册、
+ * 记忆只读（`guest`）、必须重启 DSH 才会再试一次。同时日志被
+ * `灵枢调用超时（60000ms）：initialize` 刷屏，把人引向「超时/性能」的错误方向，
+ * 而第一因是更早一行不起眼的 `spawn … ENOENT`。
+ * Windows 上 `python` 通常存在，所以该缺陷只在作者机器之外暴露。
+ *
+ * 解析顺序（高 → 低）
+ * ------------------------------------------------
+ *   ① `config.python` —— 用户显式配置，**原样尊重**（本模块不介入）
+ *   ② env `MDCG_PYTHON` —— 容器 / CI 固定解释器；命名风格与既有
+ *      `MDCG_ROOT` / `MDCG_CHILD_CWD` 一致
+ *   ③ 平台默认：`win32` → `python`（**逐字节保持既有行为**）；其它 → `python3`
+ *
+ * 边界（诚实声明，勿据此扩大承诺）
+ * ------------------------------------------------
+ * - **不做** PATH 扫描式候选回退（`python3` → `python3.12` → `python` 取首个存在）：
+ *   隐式行为在跨平台/多环境（conda、pyenv、WSL）下难以预测，且失败模式从
+ *   「明确 ENOENT」退化为「悄悄选了另一个解释器」。解释器名特殊时请显式配置
+ *   或设 `MDCG_PYTHON`。
+ * - md_cg 侧**不挑** Python 版本：只要存在解释器即可（issue 复现方实测 conda 的
+ *   `python3.12` 亦正常握手）。
+ * - 本模块只**解析名字**，不校验可执行文件是否真的存在（校验属调用方职责，
+ *   且 `stat` 结果会被 PATH/沙箱差异推翻）。
+ */
+
+/** 解释器覆盖的环境变量名（与 MDCG_ROOT 等同风格，便于容器固定）。 */
+export const PYTHON_ENV_VAR = 'MDCG_PYTHON'
+
+/**
+ * 解析默认 Python 解释器（issue #19）。
+ *
+ * 参数刻意做成**可注入**（platform / env）而非直接读全局：默认值此前写死导致的
+ * 正是「不可测 → 只在作者机器上成立」，注入后回归测试可在任意平台断言三分支。
+ */
+export function defaultPython(
+  platform: string = process.platform,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): string {
+  const explicit = (env[PYTHON_ENV_VAR] ?? '').trim()
+  if (explicit) return explicit
+  return platform === 'win32' ? 'python' : 'python3'
+}
+
+/** 自检命令文案（按平台给出**可照抄**的写法，issue #19 影响面第 4 条）。 */
+export function selfCheckCommand(python: string = defaultPython()): string {
+  return `${python} -m md_cg.mcp_server`
+}
+
+/**
+ * spawn 失败（ENOENT）时的修复指引。
+ *
+ * 为什么值得单列一条日志：该缺陷的原始日志把「解释器名不匹配」伪装成
+ * 「调用超时」，用户按超时方向排查只会浪费一轮；把成因与三条修法写在
+ * **同一行**，可诊断性直接闭环。
+ */
+export function explainMissingPython(python: string): string {
+  return `解释器「${python}」不可执行（ENOENT）。Linux/macOS 发行版按 PEP 394 只提供 `
+    + 'python3（这是默认状态，不是环境损坏）。修法（任一）：'
+    + "① cordis.yml 的 config.python 设为 'python3'（优先级最高）；"
+    + '② 设环境变量 MDCG_PYTHON=python3（容器/CI 推荐）；'
+    + '③ 确认 python3 在 PATH 中（which python3）。改完需重启 DSH。'
+}
+
+export default { defaultPython, selfCheckCommand, explainMissingPython, PYTHON_ENV_VAR }

package/docs/eval//347/254/254/344/270/211/346/226/271/351/252/214/350/257/201/346/212/245/345/221/212_LoCoMo_/347/201/265/346/236/242_.md

@@ -1,127 +0,0 @@
-# LoCoMo 第三方独立验证报告 · 灵枢标准归一化检索能力
-
-**验证人**：第三方独立评审（非灵枢系统本身）
-**日期**：2026-09-15 · **被测仓库**：`/root/lingshu-test/repo` @ `51d3426`（工作树干净）
-**数据集**：`data/benchmarks/locomo-zh-500/`（LoCoMo 500 题 / 567 条 gold 语料，上游 `mteb/LoCoMo@02e2c3de`）
-**方法**：全流程由本报告作者独立实现 —— 数据装载、查询循环、rank/hit@k/MRR 计算、随机基线、显著性检验均为本人手写，**不调用灵枢任何 `bench_*` 评测脚本**；被测对象仅为灵枢自身组件（`md_cg.mdcg.MdCG`、`md_cg.semantic.en_normalizer`、`lexicon/char_atoms_clean.json`）。唯一例外是 Jaccard 排序函数（3 行通用公开算法），由本人实现以复现灵枢主路线口径——它属于评测脚手架而非被测能力。
-
----
-
-## 一、结论速览
-
-| # | 结论 | 判定 |
-|---|------|------|
-| 1 | 灵枢自报中文检索 96.4/99.8（lexical），本人独立复现 **96.8/99.6**（MdCG 引擎） | ✅ 属实（±0.5pp 内） |
-| 2 | 灵枢自报英文主路线 96.8/99.8/99.8（臂②），本人独立复现 **96.8/99.8/99.8** | ✅ **逐位复现** |
-| 3 | 但该 99.8% 的能力来源是**中文 AI 摘要层**，不是英文归一化：去掉全部英文处理（J2_zh）反而 **97.4/99.6/100.0** | ⚠️ 归因错位 |
-| 4 | 灵枢标准归一化（`en_normalizer`）本身的真实水平：MdCG 引擎 **60.0/74.4/81.0**；主路线链路 **19.2/32.0/39.0** | ⚠️ 有效但远低于宣称口径 |
-| 5 | 归一化确实显著优于不归一：24.2% → 39.0%（+14.8pp，Jaccard 链路）；23.0% → 81.0%（**+58.0pp**，MdCG 链路） | ✅ 归一化价值成立 |
-| 6 | 71 个归一化检索失败题中，归一化后关键词"全覆盖"的题数 = **0** —— 失败 100% 归因于归一化词汇丢失/错译，而非排序机制 | 🔍 干净的因果链 |
-| 7 | OOV 如实透出（`unknown_keep`，4.0%）属实；但更危险的是 **静默错译**（`scavenger hunt`→食腐动物/猎取，`shelter`→庇护） | ⚠️ 词典对了、语境错了 |
-| 8 | 数据集非平凡性（对灵枢有利）：query 对 gold 覆盖 0.875 vs 非 gold 最佳 0.469，区分度 0.407；仅 0.2% 的题非 gold 也能满覆盖 | ✅ 不是纯字符串赠品 |
-
----
-
-## 二、主结果（本人独立运行，n=500）
-
-### 口径一：灵枢 MdCG 检索引擎（`mdcg.py` char-bigram + 四路 RRF，k=20）
-
-| 臂 | doc 侧 | hit@1 | hit@5 | hit@10 | MRR |
-|----|--------|-------|-------|--------|-----|
-| A_zh5 | 中文五槽层（AI 摘要） | **96.8%** | 99.6% | 99.6% | 0.9805 |
-| B_en_raw | 英文原文（零加工） | 15.8% | 21.6% | 23.0% | 0.1850 |
-| **C_en_norm** | **英文原文经灵枢标准归一化** | **60.0%** | 74.4% | **81.0%** | 0.6683 |
-| D_bi | 中文层 ∪ 英文归一化 | 96.6% | 99.2% | 99.2% | 0.9778 |
-| F_sem | 英文原文 + `semantic=` 归一原子（MDCG_SEMANTIC=1） | 40.0% | 63.0% | 70.2% | 0.5000 |
-| R_random | 随机排序 | 0.4% | 1.2% | 1.8% | 0.0099 |
-
-**与灵枢自报对照**（`复现结果_locomo-zh-500.json`，lexical 口径 96.4/99.8/MRR 0.9785）：本人复现 96.8/99.6/0.9805，偏差 +0.4pp / −0.2pp / +0.002，量级一致，**自报数字可信**。分题型互有 ±3pp 起伏（我 doc 侧用扁平 `zh` 串，灵枢可能用结构化 `zh_fields` + fuzzy），不改变结论。
-
-### 口径二：灵枢英文主路线同链路（字级原子映射 + 全池 Jaccard，即臂②口径）
-
-| 臂 | doc 侧原子集 | hit@1 | hit@5 | hit@10 | MRR |
-|----|--------------|-------|-------|--------|-----|
-| J2_full | 中文五槽字级映射 ∪ 英文归一词 | **96.8%** | **99.8%** | **99.8%** | 0.9807 |
-| J2_zh | 仅中文五槽字级映射 | **97.4%** | 99.6% | **100.0%** | 0.9842 |
-| J2_body | 仅英文正文归一词 | 19.2% | 32.0% | 39.0% | 0.2598 |
-| J0_raw | 英文正文原词（零归一） | 6.8% | 18.0% | 24.2% | 0.1303 |
-
-J2_full 与灵枢 `bench_en_atoms_public.py` 自报的臂② **96.8/99.8/99.8 逐位一致** —— 灵枢没有虚报数字。
-
----
-
-## 三、关键发现
-
-### 发现 1：99.8% 逐位复现 —— 可复现性满分 ✅
-
-本人独立装载、独立计算，得到与灵枢完全一致的 96.8/99.8/99.8。在以往六轮评审中"自报数字不可复现"是常见病，此处**没有任何水分**。中文口径 96.4 vs 96.8 同样在噪声内。
-
-### 发现 2：但 99.8% 归因于"英文检索能力"是错位的 ⚠️
-
-拆解链（唯一变量 = doc 侧构成，query 恒为中文关键词→字级英文原子）：
-
-- 只用中文摘要层（J2_zh）：**hit@10 = 100.0%** —— 去掉全部英文处理，比完整版还高 0.2pp；
-- 完整版（J2_full）：99.8%。**加入英文归一化层的净贡献 = −0.2pp（1 题）**；
-- MdCG 口径同构验证：A_zh5 99.6% vs D_bi 99.2%，加入英文归一化层同样无增益（McNemar 配对 b=0, c=1，p≈1.0，噪声级）。
-
-**结论：灵枢宣称的"英文（中文语义归一化桥接）96.8/99.8/99.8"本质上是"中文 AI 摘要层检索成绩"，英文归一化组件在此数字中是乘客，不是引擎。** 灵枢自己在 REPRODUCE.md 中标注了"检索侧上界口径——AI 归一环节质量未纳入该评测"，这个诚实标注是准确的，且比我们预想的更关键：不仅 AI 归一环节未纳入，**连被测的机械归一环节都对该数字无贡献**。
-
-### 发现 3：标准归一化本身的真实水平 ⚠️/✅
-
-用户点名要测的"灵枢标准归一化"（`en_normalizer.normalize_en_query`，按标准词表把英文归一翻译为中文语义原子）：
-
-- **它确实有效**：MdCG 引擎上，英文原文直接检索 23.0% → 归一化后 **81.0%（hit@10）**，+58.0pp；Jaccard 链路上 24.2% → 39.0%，+14.8pp。没有归一化，跨语言检索基本不可用。
-- **但它远够不到 99.8%**：机械归一化端到端的天花板在 81.0%（MdCG 口径）/ 39.0%（字级映射跨语言口径）。这与灵枢自己"已排除方案 9"（机械词级归一→纯中文库 33.6%）以及臂④（57.2%）的内部结论**方向一致**：灵枢文档知道机械归一不行，但 README 的显著位置仍以 96.8/99.8/99.8 作为"英文检索"的头条数字。
-- **语义摘要路（写入侧归一者正统形态，F_sem）反而更差**：40.0/63.0/70.2，且建库+检索耗时 341s（其他臂 25s 的 13 倍）。`semantic` 衍生层 + 组合窗口共现打分在本数据集上未兑现收益。
-- **根因 = 归一化语义保真率**：query 关键词被"归一化后的 gold 文档"覆盖的比例，均值 **0.460**（全覆盖题占比仅 0.2%）；同一指标对中文摘要层是 **0.873**（全覆盖 42.8%）。0.46 的保真率决定了 ~81% 的检索上限。
-
-### 发现 4：失败 100% 归因于归一化，而非检索排序 🔍
-
-C_en_norm 的 71 个未命中题中，归一化后 gold 原子对 query 关键词**全覆盖 = 0 题**、部分覆盖 65 题、零覆盖 6 题。也就是说：只要归一化把关键词保住了，MdCG 就能把它检回来；检不回来，全是因为词在归一化时就丢了/译错了。**排序机制零责任。**
-
-典型错译样本（CEDICT 词表第一义项直接套用，语境失配）：
-
-| 英文原文 | 灵枢归一化输出 | 应为 |
-|---|---|---|
-| scavenger hunt | **食腐动物 猎取** | 寻宝游戏 |
-| Three times a week | 三 **时间** 周 | 每周三次 |
-| scared | **创痕** | 害怕 |
-| shelter | **庇护** | 收容所 |
-| tough | **厉害** | 坚强 |
-| fundraiser / charades / soempowering | 原样透出（OOV） | — |
-
-### 发现 5：诚实性两面 ⚠️
-
-- **好的一面**：OOV 如实标注 `unknown_keep`（4.0%，738/18523 token）并原样透出，兑现了"词表外概念如实透出 OOV 清单"的承诺；REPRODUCE.md 主动标注"检索侧上界口径""机械归一是归一主体必须为 AI 的直接证据"，且把机械归一列为已排除方案 —— **文档层的诚实度依然很高**。
-- **坏的一面**：静默错译（`mapped` 但词义错误）无任何自检信号 —— `scavenger→食腐动物` 在 detail 里标为 `action: "mapped"`，系统认为自己译对了。52.8% 的 token 走 mapped 路径，其质量没有任何运行时护栏。README 用头条数字（99.8）树立英文检索能力预期，而支撑该数字的实为中文摘要层 —— 这属于**结构性误导**（非数据造假）。
-
-### 发现 6：数据集对灵枢有利的证伪检查 ✅
-
-我们主动检查了"零干扰池是否让 99.8% 变成字符串匹配赠品"：query 关键词对 gold 文档平均覆盖 0.875，但池内最佳非 gold 仅 0.469，平均区分度 0.407；只有 0.2% 的题存在非 gold 干扰条目满覆盖。**这个 benchmark 在 567 选 1 的粒度上仍有真实区分度**，灵枢的高分不是纯赠品——但前提是 query 关键词能被文档表示覆盖（发现 3 的保真率），而这正是中文 AI 摘要层强、机械归一化弱的地方。
-
----
-
-## 四、局限（如实声明）
-
-1. **英文原题不可得**：臂③（英文原题 81.2）/③a（78.2）/④（57.2）/⑤⑥⑦ 依赖 `data/external` 的英文原问句，该文件"自备、不入库"，本沙箱上游网络不可达（HuggingFace/GitHub TLS 全断）。**这四个对照臂第三方无法复现** —— 本报告以自建 J2_body/J0_raw 替代其对照功能。这也意味着：灵枢公开仓库当前**只能**第三方复现"上界口径"数字，其所有"下界/对照"数字均需自备数据。
-2. **AI 归一环节不可模拟**：主路线的定义就是"归一主体=AI"。本人刻意**不**用 LLM 替灵枢做归一（那会把"AI 的翻译能力"算进"灵枢的能力"）。因此本报告测的是机械归一化端到端 —— 这恰好是"系统自身组件"能兑现的真实下界。
-3. 中文口径与灵枢自报存在 ±0.4~3pp 的分题型起伏，源于 `zh` 扁平串 vs 结构化字段/fuzzy 的口径差，不影响结论方向。
-
----
-
-## 五、最终裁定
-
-> **灵枢的自报数字全部真实可复现（含 99.8% 逐位复现），且数据集本身非平凡；但其"英文检索 96.8/99.8/99.8"的能力归因是错位的 —— 该数字由中文 AI 摘要层挣得，英文标准归一化组件的真实端到端水平是 81.0%（MdCG）/ 39.0%（字级映射跨语言），离头条数字差 19~61pp。归一化模块本身"有效但有静默错译风险"：+58pp 的真实增益、4% 的诚实 OOV、以及无护栏的 52.8% mapped 词典直译。**
-
-一句话：**灵枢没有吹牛，但它把中文摘要层的功劳记在了英文归一化的账上。** 建议上游把 README 头条数字改标为"双语写入加工面检索成绩"，并为 `mapped` 路径增加语境消歧或低置信标记 —— 前者是一行文案，后者是它自己的 OOV 哲学（如实透出）尚未覆盖的最后一块。
-
----
-
-## 附录：产物清单
-
-| 文件 | 说明 |
-|---|---|
-| `灵枢_LoCoMo_第三方验证.png` | 四联图：引擎口径 / 归因拆解 / 保真率 / 分题型 |
-| `/tmp/locomo_independent_eval.py` | MdCG 引擎口径独立评测（A/B/C/D/F + 随机基线，含 `--semantic`） |
-| `/tmp/locomo_jaccard_probe.py` | 主路线 Jaccard 口径独立复现与拆解（J2_full/J2_zh/J2_body/J0_raw） |
-| `/tmp/locomo_res_*.json`、`/tmp/locomo_jaccard_res.json` | 全量逐题结果（含 miss 明细与分题型统计） |

package/docs/experiments/bench6-rust-rerun/bench_latency.py

@@ -1,116 +0,0 @@
-# -*- coding: utf-8 -*-
-"""bench6 rust 引擎检索计时：三口径 × 双语各 100 题，逐请求 perf_counter 计时。
-
-目的：补横评（docs/横评_六家100题中英双查_v1.0.md §8）中缺失的灵枢耗时行。
-口径：与竞品行同口径——「客户端端到端调用 100 题的总墙钟时间」；
-      rust 侧客户端开销 = stdin/stdout JSON 行 IPC 往返（serve 协议固有）。
-校验：计时用的同一批 hits 复算 bc.rows_from_hits + ec.summarize，
-      须与 py 基线 summary 一致——证明测的就是与横评对齐的口径。
-"""
-from __future__ import annotations
-
-import json
-import os
-import sys
-import time
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(_HERE)))
-for _p in (_ROOT, os.path.join(_ROOT, "md_cg")):
-    if _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from md_cg import bench6_common as bc      # noqa: E402
-from md_cg import eval_common as ec        # noqa: E402
-from run_rust import ARMS, BASELINE, K, ROOTS, Serve  # noqa: E402
-
-OUT_JSON = os.path.join(_HERE, "rust_latency.json")
-WARMUP = 10          # 预热请求数（页缓存/连接稳定），不计入统计
-
-
-def pct(values, q):
-    """线性插值百分位（ms）。"""
-    s = sorted(values)
-    if not s:
-        return 0.0
-    i = (len(s) - 1) * q
-    lo, hi = int(i), min(int(i) + 1, len(s) - 1)
-    return s[lo] + (s[hi] - s[lo]) * (i - lo)
-
-
-def time_arm(questions, root, paths):
-    """单臂计时：返回 (per-lang 计时统计, per-lang hits)。"""
-    stats, hits = {}, {"zh": {}, "en": {}}
-    with Serve(os.path.join(ROOTS, root), paths) as s:
-        for q in questions[: WARMUP // 2]:
-            s.search(q["question_zh"])
-            s.search(q["question_en"])
-        for lang, qkey in (("zh", "question_zh"), ("en", "question_en")):
-            ms, t0 = [], time.perf_counter()
-            for q in questions:
-                t1 = time.perf_counter()
-                hits[lang][q["qid"]] = s.search(q[qkey])
-                ms.append((time.perf_counter() - t1) * 1000.0)
-            total = time.perf_counter() - t0
-            stats[lang] = {
-                "total_s": round(total, 3), "n": len(ms),
-                "mean_ms": round(sum(ms) / len(ms), 3),
-                "p50_ms": round(pct(ms, 0.50), 3),
-                "p95_ms": round(pct(ms, 0.95), 3),
-                "max_ms": round(max(ms), 3),
-            }
-    return stats, hits
-
-
-def verify(hits, base_arm, base):
-    """同一批 hits 复算指标，与 py 基线 summary 比对。"""
-    ok = True
-    for lang in ("zh", "en"):
-        rows = bc.rows_from_hits(base["questions"], hits[lang], k=K)
-        got = ec.summarize(rows, k=K)
-        exp = base["arms"][base_arm]["langs"][lang]["summary"]
-        for m in ("hit@1", "hit@5", "mrr"):
-            if abs(got[m] - exp[m]) > 1e-9:
-                print("  [MISMATCH] %s %s: rust %.4f vs py %.4f"
-                      % (lang, m, got[m], exp[m]))
-                ok = False
-    return ok
-
-
-def main():
-    man = bc.prepare(verbose=False)
-    data = bc.load()
-    questions = data["questions"]
-    base = json.load(open(BASELINE, encoding="utf-8"))
-    # run_rust 用的 base 是裸 results json；此处兼容 dict 带 questions
-    base["questions"] = questions
-    print("[bench6-latency] 题 %d · 池 %d · 预热 %d 请求" %
-          (len(questions), man["pool"]["n"], WARMUP))
-
-    out = {"k": K, "warmup": WARMUP,
-           "engine": "rust mdcg-eval --serve (JSON 行 IPC)",
-           "arms": {}}
-    all_ok = True
-    for arm, root, paths, base_arm in ARMS:
-        print("\n== %s  (root=%s paths=%s ↔ %s)" % (arm, root, paths, base_arm))
-        stats, hits = time_arm(questions, root, paths)
-        ok = verify(hits, base_arm, base)
-        all_ok &= ok
-        for lang in ("zh", "en"):
-            st = stats[lang]
-            print("  [%s] %s  total %.3fs  mean %.3fms  p50 %.3fms  p95 %.3fms  max %.3fms"
-                  % ("OK " if ok else "BAD", lang, st["total_s"],
-                     st["mean_ms"], st["p50_ms"], st["p95_ms"], st["max_ms"]))
-        out["arms"][arm] = {"baseline_arm": base_arm,
-                            "metrics_match_baseline": ok, "latency": stats}
-
-    with open(OUT_JSON, "w", encoding="utf-8") as f:
-        json.dump(out, f, ensure_ascii=False, indent=2)
-    print("\n结果 → %s" % OUT_JSON)
-    print("口径校验：%s" % ("三组×双语指标与 py 基线一致（测的对齐口径）" if all_ok
-                           else "存在不一致——数字不可用，先排查"))
-    return 0 if all_ok else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())