acmer-coach 1.0.0

package/coach/validate_map.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+validate_map.py — MAP.yaml 结构校验（自动跑，不靠人眼）
+
+检查四件事：
+  1. 环 —— A 依赖 B、B 又依赖 A（拓扑序必须存在）
+  2. 孤儿边 —— depends 引用了一个不存在的 id
+  3. 自环 / 重复 id
+  4. 统计：入度 0 的入口节点、拓扑序（第 1 遍的产出）
+
+用法: python validate_map.py [MAP.yaml 路径]
+      默认 ~/.dsh/knowledge/MAP.yaml
+退出码: 0 通过 / 1 有错
+"""
+import os
+import sys
+
+for _s in (sys.stdout, sys.stderr):
+    if _s and hasattr(_s, "reconfigure"):
+        _s.reconfigure(encoding="utf-8", errors="replace")
+
+DEFAULT = os.path.join(os.path.expanduser("~"), ".dsh", "knowledge", "MAP.yaml")
+
+
+def load(path):
+    """读 YAML。优先用 pyyaml；没有则用极简解析（只认本文件格式）。"""
+    with open(path, "r", encoding="utf-8") as f:
+        text = f.read()
+    try:
+        import yaml
+        return yaml.safe_load(text)
+    except ImportError:
+        pass
+    # 极简 fallback：逐行扫 nodes 段的 id / depends
+    nodes, cur = [], None
+    in_nodes = False
+    for line in text.splitlines():
+        if line.startswith("nodes:"):
+            in_nodes = True
+            continue
+        if in_nodes and line and not line[0].isspace():
+            break                                    # 离开 nodes 段
+        s = line.strip()
+        if s.startswith("- id:"):
+            cur = {"id": s.split(":", 1)[1].strip(), "depends": []}
+            nodes.append(cur)
+        elif s.startswith("depends:") and cur is not None:
+            raw = s.split(":", 1)[1].strip()
+            cur["depends"] = [x.strip() for x in raw.strip("[]").split(",") if x.strip()]
+    return {"nodes": nodes}
+
+
+def main():
+    path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT
+    if not os.path.exists(path):
+        print(f"[ERR] 找不到 {path}")
+        return 1
+
+    doc = load(path)
+    nodes = doc.get("nodes") or []
+    if not nodes:
+        print("[ERR] 没解析出任何节点")
+        return 1
+
+    ids = [n["id"] for n in nodes]
+    errors = []
+
+    # 1. 重复 id
+    dup = {i for i in ids if ids.count(i) > 1}
+    if dup:
+        errors.append(f"重复 id: {sorted(dup)}")
+
+    idset = set(ids)
+
+    # 2. 孤儿边 + 自环
+    #    ⚠️ 只看 depends，**绝不要把 parent 算进来**。
+    #    parent 是「分类归属」——「树上问题」底下挂着 12 个并列的结构，
+    #    「数论」底下挂着 32 个，它们不是前置。旧版把两者合并校验，
+    #    于是报出「依赖边 315 条、入口 104 个」，看着像个漂亮的 DAG，
+    #    其实那 315 里有 177 条是分类关系，图被撑起来了而已。
+    def deps_of(n):
+        return list(n.get("depends") or [])
+
+    for n in nodes:
+        for d in deps_of(n):
+            if d == n["id"]:
+                errors.append(f"自环: {n['id']} 依赖自己")
+            elif d not in idset:
+                errors.append(f"孤儿边: {n['id']} 依赖不存在的 '{d}'")
+
+    # 3. 环检测（DFS 三色标记）
+    graph = {n["id"]: [d for d in deps_of(n) if d in idset] for n in nodes}
+    WHITE, GRAY, BLACK = 0, 1, 2
+    color = {i: WHITE for i in ids}
+    cycle = []
+
+    def dfs(u, stack):
+        color[u] = GRAY
+        stack.append(u)
+        for v in graph[u]:
+            if color[v] == GRAY:
+                i = stack.index(v)
+                cycle.append(" → ".join(stack[i:] + [v]))
+                return True
+            if color[v] == WHITE and dfs(v, stack):
+                return True
+        stack.pop()
+        color[u] = BLACK
+        return False
+
+    for i in ids:
+        if color[i] == WHITE and dfs(i, []):
+            break
+
+    if cycle:
+        errors.append(f"存在环: {cycle[0]}")
+
+    # ── 报告 ──
+    print("=" * 60)
+    print(f"MAP 校验: {path}")
+    print("=" * 60)
+    print(f"节点总数       {len(nodes)}")
+
+    domains = {}
+    for n in nodes:
+        domains.setdefault(n.get("domain", "?"), []).append(n["id"])
+    print(f"学科数         {len(domains)}")
+    for d, ns in sorted(domains.items(), key=lambda kv: -len(kv[1])):
+        print(f"    {d:8s} {len(ns):3d} 节")
+
+    unpaved = [n["id"] for n in nodes if n.get("depends") is None]
+    print(f"前置边总数     {sum(len(v) for v in graph.values())}")
+    print(f"已铺前置       {len(ids) - len(unpaved)} / {len(ids)}"
+          + (f"   ⚠️ {len(unpaved)} 个还没铺（它们的入度 0 是「不知道」，不是「根」）"
+             if unpaved else ""))
+
+    entries = [i for i in ids if not graph[i]]
+    print(f"入口节点(入度0) {len(entries)}"
+          + (f"  ← 含 {len(unpaved)} 个未铺，别当成根" if unpaved else ""))
+    for e in entries[:40]:
+        print(f"    {e}")
+    if len(entries) > 40:
+        print(f"    …（还有 {len(entries) - 40} 个）")
+
+    # 拓扑序（第 1 遍的产出 —— 学习顺序的候选）
+    # 注意边方向：graph[u] = u 的**依赖**（u 指向它的前置）。
+    # 学习顺序要求「前置先出」，所以入度 = 该节点**未满足的依赖数** = len(graph[u])，
+    # 出队时递减的是「依赖 u 的那些节点」的入度。
+    # （第一版写反了：按「有多少人依赖我」计入度，结果把最难的节点排在了最前面。）
+    dependents = {i: [] for i in ids}
+    for u, vs in graph.items():
+        for v in vs:
+            dependents[v].append(u)
+    indeg = {i: len(graph[i]) for i in ids}
+    ready = sorted([i for i in ids if indeg[i] == 0])
+    topo = []
+    while ready:
+        u = ready.pop(0)
+        topo.append(u)
+        for w in dependents[u]:
+            indeg[w] -= 1
+            if indeg[w] == 0:
+                ready.append(w)
+        ready.sort()
+    print(f"拓扑序长度     {len(topo)} / {len(ids)}"
+          + ("" if len(topo) == len(ids) else "   ⚠️ 少于节点数 = 有环"))
+
+    print()
+    if errors:
+        print(f"❌ 发现 {len(errors)} 个问题:")
+        for e in errors:
+            print(f"   - {e}")
+        return 1
+
+    print("✅ 结构合法：无环、无孤儿边、无重复 id")
+    print()
+    print("拓扑序（前 20，仅作参考 —— 真正的学习顺序还要叠权重和缺口）：")
+    for i, nid in enumerate(topo[:20], 1):
+        print(f"   {i:2d}. {nid}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/coach/verify_drag.mjs

@@ -0,0 +1,51 @@
+// 用 CDP 原生鼠标事件做一次真实拖拽，再看有没有选出一堆文字。
+// 合成事件（dispatchEvent）不会触发浏览器的原生选区，只有 Input.dispatchMouseEvent 才算数。
+const BASE = 'http://127.0.0.1:9222';
+
+const r = await (await fetch(`${BASE}/json/list`)).json();
+const page = r.find((t) => t.type === 'page' && /skilltree/.test(t.url));
+if (!page) { console.log('找不到 skilltree 页面'); process.exit(1); }
+
+const ws = new WebSocket(page.webSocketDebuggerUrl);
+let id = 0;
+const pend = new Map();
+const send = (method, params = {}, sessionId) =>
+  new Promise((res) => { const i = ++id; pend.set(i, res);
+    ws.send(JSON.stringify({ id: i, method, params, ...(sessionId ? { sessionId } : {}) })); });
+
+ws.addEventListener('message', (ev) => {
+  const m = JSON.parse(ev.data);
+  if (m.id && pend.has(m.id)) { pend.get(m.id)(m.result); pend.delete(m.id); }
+});
+await new Promise((res) => ws.addEventListener('open', res));
+
+const { sessionId } = await send('Target.attachToTarget', { targetId: page.id, flatten: true });
+
+const mouse = (type, x, y, extra = {}) =>
+  send('Input.dispatchMouseEvent',
+    { type, x, y, button: 'left', buttons: type === 'mouseReleased' ? 0 : 1, clickCount: 1, ...extra },
+    sessionId);
+
+const evalIn = async (expr) => {
+  const r = await send('Runtime.evaluate', { expression: expr, returnByValue: true }, sessionId);
+  return r?.result?.value;
+};
+
+// 先看看拖之前图上有没有残留选区
+await evalIn('getSelection().removeAllRanges()');
+
+await mouse('mousePressed', 800, 600);
+for (let i = 1; i <= 12; i++) await mouse('mouseMoved', 800 - i * 25, 600 - i * 22);  // 真实拖拽轨迹
+await mouse('mouseReleased', 500, 336);
+
+const sel = await evalIn('getSelection().toString().slice(0,120)');
+const selLen = await evalIn('getSelection().rangeCount ? getSelection().getRangeAt(0).toString().length : 0');
+const moved = await evalIn('document.querySelector("svg").style.transform');
+
+console.log(JSON.stringify({
+  选中文字长度: selLen,
+  选中内容: sel,
+  是否平移: /translate\(/.test(moved || '') && !/translate\(28px/.test(moved || ''),
+  当前transform: moved,
+}, null, 2));
+ws.close();

package/coach/verify_interact.mjs

@@ -0,0 +1,82 @@
+// 用 CDP 原生鼠标事件验交互：
+//   1) 悬停节点 → 不该亮路径
+//   2) 点击节点 → 该亮路径
+//   3) 点空白   → 该收起
+//   4) 拖一把   → 面板不该被顺手关掉
+// 合成事件测不出这些（不会走原生命中测试），必须用 Input.dispatchMouseEvent。
+const BASE = 'http://127.0.0.1:9222';
+const NODE = process.argv[2] || '树链剖分';
+
+const list = await (await fetch(`${BASE}/json/list`)).json();
+const page = list.find((t) => t.type === 'page' && /skilltree/.test(t.url));
+if (!page) { console.log('找不到 skilltree 页面'); process.exit(1); }
+
+const ws = new WebSocket(page.webSocketDebuggerUrl);
+let id = 0;
+const pend = new Map();
+const send = (method, params = {}, sessionId) =>
+  new Promise((res) => { const i = ++id; pend.set(i, res);
+    ws.send(JSON.stringify({ id: i, method, params, ...(sessionId ? { sessionId } : {}) })); });
+ws.addEventListener('message', (ev) => {
+  const m = JSON.parse(ev.data);
+  if (m.id && pend.has(m.id)) { pend.get(m.id)(m.result); pend.delete(m.id); }
+});
+await new Promise((res) => ws.addEventListener('open', res));
+const { sessionId } = await send('Target.attachToTarget', { targetId: page.id, flatten: true });
+
+const evalIn = async (expr) =>
+  (await send('Runtime.evaluate', { expression: expr, returnByValue: true }, sessionId))?.result?.value;
+const mouse = (type, x, y, extra = {}) =>
+  send('Input.dispatchMouseEvent',
+    { type, x, y, button: 'left', buttons: type === 'mouseReleased' ? 0 : 1, clickCount: 1, ...extra },
+    sessionId);
+
+// 数「看得见的」高亮 —— 光数类名会把 display:none 的也算进去
+const snap = () => evalIn(`JSON.stringify({
+  hotNodes: [...document.querySelectorAll('.node.hot')].filter(e=>e.style.display!=='none').length,
+  hotEdges: [...document.querySelectorAll('path.edge.hot')].filter(e=>e.style.display!=='none').length,
+  staleEdges: [...document.querySelectorAll('path.edge.hot')].filter(e=>e.style.display==='none').length,
+  panel: document.querySelector('#panel').classList.contains('on'),
+})`).then(JSON.parse);
+
+const at = async (id) => JSON.parse(await evalIn(
+  `(() => { const g=[...document.querySelectorAll('.node')].find(e=>e.dataset.id===${JSON.stringify(id)});
+    if(!g) return 'null'; const r=g.getBoundingClientRect();
+    return JSON.stringify({x:r.x+r.width/2, y:r.y+r.height/2}); })()`));
+
+const pos = await at(NODE);
+if (!pos) { console.log(`节点 ${NODE} 不在视口里`); process.exit(1); }
+const out = {};
+
+// 1) 悬停
+await mouse('mouseMoved', pos.x, pos.y, { button: 'none', buttons: 0 });
+await new Promise((r) => setTimeout(r, 250));
+out['1_悬停'] = await snap();
+
+// 2) 点击
+await mouse('mousePressed', pos.x, pos.y);
+await mouse('mouseReleased', pos.x, pos.y);
+await new Promise((r) => setTimeout(r, 250));
+out['2_点击后'] = await snap();
+
+// 3) 拖一把（面板应保留）
+await mouse('mousePressed', 500, 800);
+for (let i = 1; i <= 8; i++) await mouse('mouseMoved', 500 + i * 12, 800 + i * 4);
+await mouse('mouseReleased', 596, 832);
+await new Promise((r) => setTimeout(r, 250));
+out['3_拖拽后'] = await snap();
+
+// 4) 点空白（面板应收起）
+await mouse('mousePressed', 300, 900);
+await mouse('mouseReleased', 300, 900);
+await new Promise((r) => setTimeout(r, 250));
+out['4_点空白后'] = await snap();
+
+out['判定'] = {
+  '悬停不亮': out['1_悬停'].hotEdges === 0 && out['1_悬停'].hotNodes === 0,
+  '点击才亮': out['2_点击后'].hotEdges > 0 && out['2_点击后'].panel,
+  '拖拽不误关': out['3_拖拽后'].panel === true,
+  '点空白收起': out['4_点空白后'].panel === false && out['4_点空白后'].hotNodes === 0,
+};
+console.log(JSON.stringify(out, null, 2));
+ws.close();

package/coach/verify_serve.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+verify_serve.py — 验收 serve_map.py 的进度接口（/api/progress）
+
+在**临时目录**跑（COACH_DATA_DIR 指过去），绝不碰真的 PROGRESS.yaml。
+CLI 子进程继承这个环境变量，所以整条链路（HTTP → Python → node → 文件）
+都落在临时目录里。
+
+用法: python verify_serve.py        （不需要先起 serve_map.py，本脚本自己起）
+"""
+import json
+import os
+import shutil
+import sys
+import tempfile
+import threading
+import urllib.error
+import urllib.request
+from http.server import HTTPServer
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+import serve_map  # noqa: E402
+
+for _s in (sys.stdout, sys.stderr):
+    if _s and hasattr(_s, "reconfigure"):
+        _s.reconfigure(encoding="utf-8", errors="replace")
+
+fails = []
+
+
+def check(label, cond, extra=""):
+    print(f"{'  OK  ' if cond else '  FAIL'} {label}" + (f"  → {extra}" if extra else ""))
+    if not cond:
+        fails.append(label)
+
+
+MINI_MAP = """meta: { version: 9, node_count: 3 }
+nodes:
+  - id: A
+    name: A
+    domain: 测试
+    depends: []
+  - id: B
+    name: B
+    domain: 测试
+    depends: [A]
+  - id: C
+    name: C
+    domain: 测试
+    depends: [A]
+"""
+
+tmp = tempfile.mkdtemp(prefix="coach-serve-")
+Path(tmp, "MAP.yaml").write_text(MINI_MAP, encoding="utf-8")
+Path(tmp, "skilltree.html").write_text("<html>stub</html>", encoding="utf-8")
+os.environ["COACH_DATA_DIR"] = tmp
+
+# 起服务（换掉目录和端口，别抢真的 8770，也别弹浏览器）
+serve_map.ROOT = tmp
+serve_map.PORT = 8791
+PORT = 8791
+
+httpd = HTTPServer(("127.0.0.1", PORT), lambda *a, **k: serve_map.Handler(
+    *a, directory=tmp, **k))
+threading.Thread(target=httpd.serve_forever, daemon=True).start()
+BASE = f"http://127.0.0.1:{PORT}/api/progress"
+
+
+def get():
+    with urllib.request.urlopen(BASE, timeout=10) as r:
+        return json.loads(r.read().decode("utf-8"))
+
+
+def post(payload):
+    req = urllib.request.Request(
+        BASE, data=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"}, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return r.status, json.loads(r.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        return e.code, json.loads(e.read().decode("utf-8"))
+
+
+print("── 1. 接口通不通 ──")
+p = get()
+check("GET 返回空进度", p.get("ok") is True and p.get("cursor") == "", json.dumps(p, ensure_ascii=False))
+
+st, r1 = post({"op": "mark", "node": "A", "status": "learned"})
+check("POST 标记学过", st == 200 and r1.get("ok") is True, json.dumps(r1, ensure_ascii=False))
+# ★ 闸门：verified 手标必须被挡住（自评 ≠ 检测结论）
+st, rv = post({"op": "mark", "node": "A", "status": "verified"})
+check("★ 手标 verified → 400（已验证只能靠检测）",
+      st == 400 and rv.get("ok") is False, json.dumps(rv, ensure_ascii=False))
+st, r2 = post({"op": "mark", "node": "B", "status": "studying"})
+check("POST 标记在学", st == 200 and r2.get("ok") is True)
+
+p = get()
+check("★ 再 GET 读得到刚写的（不是各存一份）",
+      p["nodes"].get("A", {}).get("status") == "learned"
+      and p["nodes"].get("B", {}).get("status") == "studying",
+      json.dumps(p["nodes"], ensure_ascii=False))
+
+print("── 2. 游标 ──")
+st, r3 = post({"op": "cursor", "node": "A"})
+check("POST 设游标", st == 200 and r3.get("cursor") == "A")
+check("GET 读得到游标", get()["cursor"] == "A")
+
+print("── 3. 该挡的要挡住 ──")
+st, r4 = post({"op": "mark", "node": "不存在的节点", "status": "learned"})
+check("不存在的节点 → 400 而不是静默成功", st == 400 and r4.get("ok") is False,
+      json.dumps(r4, ensure_ascii=False))
+st, r5 = post({"op": "mark", "node": "A", "status": "乱写的状态"})
+check("非法状态 → 400", st == 400 and r5.get("ok") is False)
+st, r6 = post({"op": "瞎写", "node": "A"})
+check("未知 op → 400", st == 400 and r6.get("ok") is False)
+
+print("── 4. 退回未学 ──")
+st, _ = post({"op": "mark", "node": "B", "status": "none"})
+check("none 把条目删掉（回到未学）", "B" not in get()["nodes"], json.dumps(get()["nodes"], ensure_ascii=False))
+
+print("── 5. 关键：文件里是真的落盘了 ──")
+raw = Path(tmp, "PROGRESS.yaml").read_text(encoding="utf-8")
+check("PROGRESS.yaml 真有内容", "A" in raw and "learned" in raw)
+check("文件头还在（没被 YAML dump 冲掉）", "唯一真相源" in raw,
+      raw.splitlines()[1] if raw else "(空)")
+
+httpd.shutdown()
+shutil.rmtree(tmp, ignore_errors=True)
+
+print()
+if fails:
+    print(f"✗ {len(fails)} 条没过：")
+    for f in fails:
+        print(f"   · {f}")
+    sys.exit(1)
+print("✓ 全部通过")

package/cordis.patch.yml

@@ -0,0 +1,10 @@
+# acmer-coach 组合层（bundle 形态）。
+#
+# ⚠️ 两条路**不能并存**：这份 insert 和 profile 的 cordis.patch.yml 里再来
+# 一条 insert，插件就会被挂两次。profile 那边现在是空的（留了说明）。
+#
+# ⚠️ id 必须和 index.js 导出的 `name` 逐字相同，name 必须和**包名**相同 ——
+# 对不上不会报错，工具会**静默不注册**，界面上完全看不出区别。
+- insert:
+    - id: acmer-coach
+      name: 'acmer-coach'

package/dev/parity-check.mjs

@@ -0,0 +1,169 @@
+// 保真度审计：开源版和线上那份，喂**同样的输入**，逐条比输出。
+//
+// 为什么要有这个：改了一堆东西（解绑路径、加两个工具、清注释、改名字），
+// 单测全绿只能证明"新的这份自己跑得通"，**证明不了"它和原来那只是同一只"**。
+// 而用户要的正是后者。
+//
+// 做法：准备两份**逐字节相同**的临时数据目录，各喂给一个版本，
+// 跑同一串调用，把返回值拉平了对比。允许的差异只有三处，都写在下面。
+//
+// 跑法：node dev/parity-check.mjs
+import { mkdtempSync, writeFileSync, readFileSync, cpSync, existsSync, rmSync } from 'node:fs'
+import { tmpdir, homedir } from 'node:os'
+import { join } from 'node:path'
+
+const LIVE = process.env.COACH_LIVE_INDEX
+  || join(homedir(), '.dsh', 'profiles', 'web', 'node_modules', 'dsh-coach', 'index.js')
+
+let pass = 0, fail = 0, diff = 0
+const check = (n, ok, d = '') => { console.log(`${ok ? '  ✓' : '  ✗'} ${n}${d ? `  — ${d}` : ''}`); ok ? pass++ : fail++ }
+
+if (!existsSync(LIVE)) {
+  console.log(`✗ 找不到线上那份：${LIVE}`)
+  console.log('  （设 COACH_LIVE_INDEX 指到它的 index.js）')
+  process.exit(1)
+}
+
+// ── 造两份逐字节相同的夹具数据目录 ──────────────────────────────────
+// 两边各一份而不是共用一份：工具会**写**（coach_assign 落盘），
+// 共用的话后跑的那个看到的是先跑的那个改过的状态，比出来的差异是假的。
+const base = mkdtempSync(join(tmpdir(), 'parity-'))
+const ASSETS = join(import.meta.dirname, '..', 'assets', 'knowledge')
+const PROG = `version: 1
+cursor: 动态规划基础
+updated: 2000-01-01
+nodes:
+  区间 DP:
+    status: studying
+    at: 2000-01-01
+  记忆化搜索:
+    status: learned
+    at: 2000-01-01
+`
+const SCHED = `version: 1
+updated: "2000-01-01"
+days: {}
+`
+for (const d of ['A', 'B']) {
+  const dir = join(base, d)
+  cpSync(ASSETS, dir, { recursive: true })
+  writeFileSync(join(dir, 'PROGRESS.yaml'), PROG)
+  writeFileSync(join(dir, 'SCHEDULE.yaml'), SCHED)
+}
+
+const mockCtx = (reg) => ({ tools: { register: (t) => reg.push(t) }, inject: () => {}, on: () => {}, get: () => undefined })
+
+async function loadCopy(indexPath, dataDir, tag) {
+  process.env.COACH_DATA_DIR = dataDir
+  process.env.COACH_DB = join(dataDir, 'no-db.sqlite')     // 两边都没有库 → 走降级路径
+  const mod = await import(`file:///${indexPath.replace(/\\/g, '/')}?parity=${tag}`)
+  const reg = []
+  mod.apply(mockCtx(reg))
+  return { mod, byName: new Map(reg.map((t) => [t.name, t])) }
+}
+
+const A = await loadCopy(join(import.meta.dirname, '..', 'index.js'), join(base, 'A'), 'oss')
+const B = await loadCopy(LIVE, join(base, 'B'), 'live')
+
+console.log('── 1. 工具清单 ──')
+const namesA = [...A.byName.keys()].sort()
+const namesB = [...B.byName.keys()].sort()
+const onlyB = namesB.filter((n) => !namesA.includes(n))
+const onlyA = namesA.filter((n) => !namesB.includes(n))
+check('开源版没有丢掉任何原有工具', onlyB.length === 0, onlyB.join(',') || '（没丢）')
+// 新增的只能是「搭环境 / 拉数据 / 查知识」这三类 —— 它们补的正是
+// 开源版缺的那些基础设施（原版靠本地已有的库和 skill，别人没有）。
+const EXPECTED_NEW = new Set(['coach_setup', 'coach_wiki', 'coach_import'])
+check('新增的都在预期内（搭建 / 检索 / 导入）',
+  onlyA.every((n) => EXPECTED_NEW.has(n)), onlyA.join(',') || '（无新增）')
+check('原有的 17 个行为没变（下面逐条比）', namesB.length === 17, `${namesB.length} 个`)
+console.log(`     线上 ${namesB.length} 个 / 开源 ${namesA.length} 个（+${onlyA.join(', ') || '无'}）`)
+
+console.log('\n── 2. 共有工具：同样的输入 → 同样的输出 ──')
+// 每条：[工具, 参数, 说明]
+const CALLS = [
+  ['coach_next', { cursor: '动态规划基础' }, '游标的下层候选'],
+  ['coach_next', { cursor: '并不存在的知识点' }, '打错字'],
+  ['coach_status', {}, '读进度'],
+  ['coach_schedule', {}, '读日程'],
+  ['coach_pool', { node: '区间 DP' }, '查题池（无库 → 降级）'],
+  ['coach_assign', { cursor: '动态规划基础', node: '区间 DP', deliverable: '贴代码', minutes: 40 }, '布置（新知识点不给讲解段）'],
+  ['coach_assign', { cursor: '动态规划基础', node: '区间 DP', deliverable: '贴代码', minutes: 40, teachMinutes: 15 }, '布置（带讲解段）'],
+  ['coach_assign', { cursor: '动态规划基础', node: '不存在的节点', deliverable: 'x', minutes: 40 }, '布置到地图外'],
+  ['coach_diagnose', { code: 'int main(){return 0;}', problem: '1015D', category: '不认真', node: '区间 DP', evidence: [], summary: '测试' }, '判因'],
+  ['coach_mark', { node: '记忆化搜索', status: 'verified' }, '手标 verified（该被拒）'],
+  ['coach_set_cursor', { node: '区间 DP' }, '移游标'],
+  ['coach_ping', {}, '探针'],
+]
+
+// 归一化：把**有意不同**的东西抹平，免得假差异淹掉真差异。
+//   ① 包名（改名了）
+//   ② 数据目录路径（两份故意用不同临时目录，否则后跑的会看到先跑的那份被写过）
+const ALLOWED = [
+  ['name', /^(dsh-coach|acmer-coach)$/],
+  ['version', /^1\.0\.0$/],
+]
+const strip = (s) => s
+  .replace(/acmer-coach/g, 'dsh-coach')
+  .split(join(base, 'A')).join('<DATA>')
+  .split(join(base, 'B')).join('<DATA>')
+  .split(base).join('<DATA>')
+  .replace(/\\\\/g, '/').replace(/\//g, '/').split('<DATA>').join('<DATA>')
+const norm = (v) => JSON.parse(JSON.stringify(v ?? null, (k, x) =>
+  typeof x === 'string' ? strip(x) : x))
+
+for (const [tool, args, label] of CALLS) {
+  const ta = A.byName.get(tool), tb = B.byName.get(tool)
+  if (!ta || !tb) { check(`${tool} · ${label}`, false, '有一边没这个工具'); continue }
+  let ra, rb, ea, eb
+  try { ra = norm(await ta.execute(args, undefined)) } catch (e) { ea = e.message }
+  try { rb = norm(await tb.execute(args, undefined)) } catch (e) { eb = e.message }
+  const sa = JSON.stringify(ra ?? { ERR: ea }), sb = JSON.stringify(rb ?? { ERR: eb })
+  if (sa === sb) { check(`${tool} · ${label}`, true) }
+  else {
+    // 探针那类返回值里带包名/路径，逐键比
+    const ka = Object.keys(ra ?? {}), kb = Object.keys(rb ?? {})
+    const dk = [...new Set([...ka, ...kb])].filter((k) => JSON.stringify(ra?.[k]) !== JSON.stringify(rb?.[k]))
+    const benign = dk.every((k) => ALLOWED.some(([n]) => k === n))
+    if (benign) { check(`${tool} · ${label}`, true, `仅包名/版本不同（${dk.join(',')}）`) }
+    else { diff++; check(`${tool} · ${label}`, false, `差异字段：${dk.join(', ')}`) }
+  }
+}
+
+console.log('\n── 3. 渲染文本：他看到的那些字 ──')
+for (const [tool, args, label] of CALLS.filter((c) => c[0] !== 'coach_diagnose')) {
+  const ta = A.byName.get(tool), tb = B.byName.get(tool)
+  if (!ta?.output?.render || !tb?.output?.render) continue
+  let va, vb
+  try { va = await ta.execute(args, undefined) } catch { continue }
+  try { vb = await tb.execute(args, undefined) } catch { continue }
+  const ra = strip(ta.output.render(args, va)[0]?.text ?? '')
+  const rb = strip(tb.output.render(args, vb)[0]?.text ?? '')
+  const same = ra === rb
+  check(`渲染 · ${tool} · ${label}`, same, same ? '' : '文本不一致')
+}
+
+console.log('\n── 4. 规则覆盖度（线上 AGENTS.md vs 打包的规则文件）──')
+{
+  const rules = readFileSync(join(import.meta.dirname, '..', 'assets', 'rules', 'coach-rules.md'), 'utf8')
+  // 线上规则里的九条硬规则，在开源版里都要能找到对应
+  const MARKS = [
+    ['一次只给一个动作', /一次只给一个动作|禁止候选列表/],
+    ['指令走 coach_assign', /coach_assign/],
+    ['先讲再出题', /先讲，再出题|开一个他从没碰过的知识点/],
+    ['判因要引代码原文', /引用.*代码.*原文|原文片段/],
+    ['检测由教练主动提', /检测是你主动提的/],
+    ['tier/entry/at 三样', /tier.*entry.*at|entry.*学不学得起/],
+    ['排块走 schedule→plan', /排训练时间走/],
+    ['反依赖（不给答案）', /禁止直接给完整解法/],
+    ['元认知动作', /元认知/],
+    ['时间铁律', /报时铁律/],
+    ['安全红线', /Prompt 注入防御/],
+    ['赛场读题', /区域赛难度分布随机/],
+  ]
+  for (const [name, re] of MARKS) check(`规则含「${name}」`, re.test(rules))
+}
+
+rmSync(base, { recursive: true, force: true })
+console.log(`\n${fail === 0 ? '✓ 保真度通过' : '✗ 有差异'} — ${pass} 通过 / ${fail} 失败（其中 ${diff} 条是真差异）`)
+process.exit(fail === 0 ? 0 : 1)