eduevidence 5.2.0

package/scripts/startup_probe.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""startup_probe.py — Skill 启动能力检测（SKILL.md §5.5 启动清单动态填充）。
+
+只探测【主会话看不到的信息】：
+  1. Agent MCP 配置状态（MCP 工具可见性以会话内为准）
+  2. 各 CLI 当前可用的模型（按 provider 段解析，保留前缀端点；系列只列最新）
+
+【不探测】宿主原生子代理池——主会话模型自己就能直接看见（task/scout/reviewer 等）。
+
+⚠️ 模型名=完整端点：中转站注入的模型名带 provider 段前缀（如 opencodex/pro/gpt-5.6-sol、
+opencode-go/deepseek-v4-flash），同一后缀不同前缀是不同端点。派发时必须使用完整模型名。
+
+用法：
+    python3 scripts/startup_probe.py             # JSON 输出
+    python3 scripts/startup_probe.py --markdown  # 输出启动清单的"当前会话能力检测"段
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+# 各 CLI 的探测命令（存在才列）
+CLI_PROBES: dict[str, list[str]] = {
+    "omp": ["omp", "models"],
+    "codex": ["codex", "--help"],
+    "claude": ["claude", "--version"],
+    "opencode": ["opencode", "--version"],
+    "grok": ["grok", "--version"],
+    "kimi": ["kimi", "--version"],
+}
+
+# 各系列"最新模型"显示顺序（按系列去重，只列最新）
+# 档位：旗舰（FLAGSHIP）= 复杂推理/裁决；基础（BASE）= 检索/抽取/结构化
+SERIES_PRIORITY = [
+    # OpenAI 系
+    "gpt-5.5", "gpt-5.6-sol", "gpt-5.6-luna", "gpt-5.6-terra",
+    # Anthropic 系
+    "claude-opus-5", "claude-fable-5", "claude-sonnet-5",
+    # DeepSeek 系
+    "deepseek-v4-pro", "deepseek-v4-flash", "ds-flash",
+    # GLM 系
+    "glm-5.3", "glm-5.2", "glm-5.1",
+    # Kimi 系
+    "kimi-k3", "kimi-k2.7",
+    # 其余
+    "qwen3.8-max", "qwen3.7-plus",
+    "minimax-m3", "minimax-m2.7",
+    "grok-4.5",
+]
+
+# 档位标注（展示用；不写死路由，路由以用户授权为准）
+MODEL_TIERS = {
+    # 旗舰（strong / independent）
+    "gpt-5.5": "FLAGSHIP", "gpt-5.6-sol": "FLAGSHIP",
+    "claude-opus-5": "FLAGSHIP", "claude-fable-5": "FLAGSHIP",
+    "glm-5.3": "FLAGSHIP", "deepseek-v4-pro": "FLAGSHIP", "kimi-k3": "FLAGSHIP",
+    # 基础（fast）
+    "ds-flash": "BASE", "deepseek-v4-flash": "BASE",
+    "gpt-5.6-luna": "BASE", "gpt-5.6-terra": "BASE",
+    "claude-sonnet-5": "BASE", "glm-5.2": "BASE", "glm-5.1": "BASE",
+    "kimi-k2.7": "BASE",
+}
+
+# 模型默认思考等级（主会话内置知识，无需用户确认）
+THINKING_LEVELS = {
+    "deepseek-v4-flash": "max",
+    "deepseek-v4-pro": "max",
+    "ds-flash": "max",
+    "gpt-5.5": "high",
+    "gpt-5.6-sol": "high",
+    "gpt-5.6-luna": "high",
+    "gpt-5.6-terra": "high",
+    "claude-opus-5": "high",
+    "claude-fable-5": "high",
+    "claude-sonnet-5": "high",
+    "glm-5.3": "high",
+    "glm-5.2": "high",
+    "glm-5.1": "high",
+    "kimi-k3": "high",
+    "kimi-k2.7": "high",
+    "qwen3.8-max": "high",
+    "qwen3.7-plus": "high",
+    "minimax-m3": "high",
+    "minimax-m2.7": "high",
+    "grok-4.5": "high",
+}
+
+# 前缀端点：同一后缀不同前缀是不同端点，保留完整名
+KNOWN_PREFIXES = ("pro/", "jbb/", "pix/", "pixgrok/", "opencode-go/", "deepseek/", "combo/")
+
+
+def detect_agent_mcp_tools() -> dict:
+    """探测 Agent MCP 配置状态（最终以会话内 spawn_agent 工具可见性为准）。"""
+    mcp_json = Path.home() / ".omp" / "agent" / "mcp.json"
+    configured = False
+    if mcp_json.exists():
+        try:
+            cfg = json.loads(mcp_json.read_text())
+            configured = "agent-mcp" in cfg.get("mcpServers", {})
+        except json.JSONDecodeError:
+            configured = False
+    return {
+        "configured": configured,
+        "config_path": str(mcp_json) if mcp_json.exists() else None,
+        "note": "最终以会话内 spawn_agent 工具可见性为准",
+    }
+
+
+def scan_cli_models(cli: str) -> list[dict]:
+    """扫描 CLI 模型列表，返回 [{provider, model(完整名), thinking}]。
+
+    解析 omp 风格分段输出：
+        opencode-go (25)      <- provider 段
+        │ gpt-5.6-luna ...    <- 段内模型（可能带 pro/ jbb/ 前缀）
+    完整模型名 = provider + "/" + 段内名（段内无前缀时即 provider 内模型）。
+    """
+    probe = CLI_PROBES.get(cli)
+    if not probe or shutil.which(probe[0]) is None:
+        return []
+    try:
+        out = subprocess.run(probe, capture_output=True, text=True, timeout=15)
+    except (subprocess.SubprocessError, OSError):
+        return []
+
+    records: list[dict] = []
+    provider: str | None = None
+    for line in (out.stdout + out.stderr).splitlines():
+        s = line.strip()
+        # provider 段头：`opencode-go (25)` / `opencodex (18)`
+        m = re.match(r"^([\w.-]+)\s+\(\d+\)$", s)
+        if m and "│" not in s and "┌" not in s and "└" not in s:
+            provider = m.group(1)
+            continue
+        # 数据行：`│ model-name  │ ...`
+        if not s.startswith("│") or "model" in s or set(s) <= {"│", "─", " "}:
+            continue
+        parts = [p.strip() for p in s.strip("│").split("│")]
+        if not parts or not parts[0]:
+            continue
+        name = parts[0]
+        if not re.match(r"^[\w./-]+$", name) or name in ("model",):
+            continue
+        full = f"{provider}/{name}" if provider else name
+        records.append({
+            "provider": provider or "?",
+            "model": full,
+            "thinking": _thinking_for(full),
+        })
+    return records
+
+
+def _thinking_for(model: str) -> str:
+    level = "high"
+    for key, lv in THINKING_LEVELS.items():
+        if key in model:
+            level = lv
+            break
+    return level
+
+
+def _series_family(model: str) -> str:
+    """模型所属系列族（用于去重）：取已知系列前缀的根。"""
+    for fam in ("gpt", "deepseek", "glm", "kimi", "qwen", "minimax", "grok", "hy"):
+        if fam in model:
+            return fam
+    return model.split("/")[-1].split("-")[0]
+
+
+def latest_by_series(records: list[dict], limit: int = 8) -> list[dict]:
+    """按系列去重，各系列只列最新（含前缀端点）。"""
+    picked: list[dict] = []
+    seen_families: set[str] = set()
+    for ref in SERIES_PRIORITY:
+        matches = [r for r in records if ref in r["model"]]
+        if not matches:
+            continue
+
+        def rank(r: dict) -> int:
+            m = r["model"]
+            if "pro/" in m:
+                return 1  # pro 路由档
+            if "jbb/" in m:
+                return 2
+            if "pix/" in m or "pixgrok/" in m:
+                return 3
+            return 0  # 默认端点（含 provider 前缀但无路由后缀）优先
+
+        matches.sort(key=rank)
+        chosen = matches[0]
+        fam = _series_family(chosen["model"])
+        if fam in seen_families:
+            # 例外：deepseek 系列同时保留 pro 与 flash（档位不同，都是常用选择）
+            if not (fam == "deepseek" and
+                    all("flash" not in p["model"] for p in picked)):
+                continue
+        seen_families.add(fam)
+        picked.append(chosen)
+        if len(picked) >= limit:
+            break
+    return picked
+
+
+def probe_all() -> dict:
+    report = {
+        "agent_mcp": detect_agent_mcp_tools(),
+        "clis": {},
+        "note_native_pool": "宿主原生子代理池由主会话直接可见（task/scout/reviewer），无需探测",
+        "note_prefix": "模型名含 provider 前缀=完整端点，派发必须使用完整名",
+    }
+    for cli in CLI_PROBES:
+        records = scan_cli_models(cli)
+        report["clis"][cli] = {
+            "available": bool(records) or shutil.which(CLI_PROBES[cli][0]) is not None,
+            "models": latest_by_series(records) if records else [],
+        }
+    return report
+
+
+def render_markdown(report: dict) -> str:
+    am = report["agent_mcp"]
+    lines = ["### 当前会话能力检测", ""]
+    lines.append(
+        "- Agent MCP：" + ("● 已连接（spawn_agent 可用，以会话内工具可见性为准）"
+                           if am["configured"] else "○ 未发现") + "")
+    lines.append("")
+    # 当前会话可用模型（主会话直接可见，两种情况都列出）
+    lines.append("- **当前会话可用模型（主会话直接可见）**：原生子代理池 task / scout / reviewer …")
+    lines.append("")
+    if am["configured"]:
+        lines.append("- **Agent MCP 可用，追加 CLI + 模型**（不同系列各列最新；思考等级默认值；完整名=端点）：")
+        for cli, info in report["clis"].items():
+            if not info["available"]:
+                lines.append(f"  `{cli}`: （未检测到）")
+                continue
+            if not info["models"]:
+                lines.append(f"  `{cli}`: （模型列表待扫描）")
+                continue
+            items = " · ".join(f"`{m['model']}`({m['thinking']})" for m in info["models"])
+            lines.append(f"  `{cli}`: {items}")
+    else:
+        lines.append("- Agent MCP 未发现：不列出 CLI/模型（那是 Agent MCP 的模型选项），推荐先安装 Agent MCP")
+        lines.append("  （`~/.omp/agent/mcp.json` 注册 spawn_agent 后重启会话即可增强）；当前用主会话原生子代理池执行。")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Skill 启动能力检测")
+    parser.add_argument("--markdown", action="store_true", help="输出启动清单的检测段")
+    args = parser.parse_args()
+
+    report = probe_all()
+    if args.markdown:
+        print(render_markdown(report))
+    else:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/sync_killer_demo_report.py

@@ -0,0 +1,270 @@
+"""scripts/sync_killer_demo_report.py — Synchronizes the 50-study SSOT EvidenceGraph into result.json and renders EduEvidence_Report.html."""
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from engine.evidence_graph import EvidenceGraph
+
+def sync_report():
+    target_dir = ROOT / "examples" / "ai-coding-assistant-50"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    graph_file = target_dir / "evidence_graph.json"
+    result_en_file = target_dir / "result.json"
+    result_zh_file = target_dir / "result.zh.json"
+
+    if not graph_file.exists():
+        # Fallback to build_killer_demo
+        from scripts.build_killer_demo import export_all
+        export_all()
+
+    graph = EvidenceGraph.from_json(graph_file.read_text(encoding="utf-8"))
+
+    orig_en = ROOT / "examples" / "ai-coding-assistant" / "result.json"
+    orig_zh = ROOT / "examples" / "ai-coding-assistant" / "result.zh.json"
+    en_data = json.loads(result_en_file.read_text(encoding="utf-8")) if result_en_file.exists() else (json.loads(orig_en.read_text(encoding="utf-8")) if orig_en.exists() else {})
+    zh_data = json.loads(result_zh_file.read_text(encoding="utf-8")) if result_zh_file.exists() else (json.loads(orig_zh.read_text(encoding="utf-8")) if orig_zh.exists() else {})
+
+    # 1. Update Sources
+    sources_en = []
+    sources_zh = []
+    for p in graph.papers.values():
+        s_item = {
+            "source_id": p.paper_id,
+            "title": p.title,
+            "authors": p.authors,
+            "year": p.year,
+            "venue": p.venue,
+            "doi": p.doi,
+            "canonical_url": p.url or f"https://doi.org/{p.doi}",
+            "authority_level": f"tier{p.authority_tier}_peer_reviewed",
+            "source_location": p.url or f"https://doi.org/{p.doi}",
+        }
+        sources_en.append(s_item)
+        sources_zh.append(s_item)
+
+    en_data["sources"] = sources_en
+    zh_data["sources"] = sources_zh
+
+    # 2. Update Evidence array
+    ev_list_en = []
+    ev_list_zh = []
+    
+    for ev in graph.evidence.values():
+        paper = graph.papers.get(ev.paper_id)
+        val = ev.effect_size.get("value", 0.0)
+        
+        # Canonical outcome mapping matching existing outcome taxonomy tokens
+        if ev.outcome_dimension == "PROCEDURAL_EFFICIENCY":
+            otype = "completion_time"
+            otype_zh = "completion_time"
+        elif ev.outcome_dimension == "INDEPENDENT_TRANSFER":
+            otype = "independent_problem_solving"
+            otype_zh = "independent_problem_solving"
+        elif ev.outcome_dimension == "CONCEPTUAL_MASTERY":
+            otype = "code_quality"
+            otype_zh = "code_quality"
+        else:
+            otype = "ai_dependency"
+            otype_zh = "ai_dependency"
+
+        ev_en_item = {
+            "evidence_id": ev.evidence_id,
+            "source_id": ev.paper_id,
+            "title": paper.title if paper else ev.paper_id,
+            "study_label": f"{paper.authors[0] if paper and paper.authors else ev.paper_id} ({paper.year if paper else 2024})",
+            "year": paper.year if paper else 2024,
+            "outcome_type": otype,
+            "outcome_dimension": ev.outcome_dimension,
+            "outcome_metric": ev.outcome_metric,
+            "effect_direction": "positive" if val > 0.10 else ("negative" if val < -0.05 else "null"),
+            "relation_to_claim": "support" if ev.direction == "SUPPORTS" else ("contradict" if ev.direction == "CONTRADICTS" else "neutral"),
+            "effect_size": ev.effect_size,
+            "sample_size": ev.sample_size,
+            "study_design": ev.study_design,
+            "quality_score": int(ev.confidence_score * 10),
+            "wwc_rating": ev.wwc_rating,
+            "url": paper.url if paper else f"https://doi.org/{ev.paper_id}",
+            "key_quote": ev.key_quote,
+        }
+
+        ev_zh_item = dict(ev_en_item)
+        ev_zh_item["outcome_type"] = otype
+        ev_zh_item["outcome_metric"] = ev.outcome_metric
+
+        ev_list_en.append(ev_en_item)
+        ev_list_zh.append(ev_zh_item)
+
+    en_data["evidence"] = ev_list_en
+    zh_data["evidence"] = ev_list_zh
+
+    # Compute outcomes array dynamically from evidence to pass integrity gate
+    outcome_buckets: dict[str, dict] = {}
+    for ev in ev_list_en:
+        ot = ev["outcome_type"]
+        if ot not in outcome_buckets:
+            outcome_buckets[ot] = {
+                "outcome_type": ot,
+                "positive_count": 0,
+                "negative_count": 0,
+                "null_count": 0,
+                "evidence_ids": [],
+            }
+        edir = ev["effect_direction"]
+        if edir == "positive":
+            outcome_buckets[ot]["positive_count"] += 1
+        elif edir == "negative":
+            outcome_buckets[ot]["negative_count"] += 1
+        else:
+            outcome_buckets[ot]["null_count"] += 1
+        outcome_buckets[ot]["evidence_ids"].append(ev["evidence_id"])
+
+    en_data["outcomes"] = list(outcome_buckets.values())
+    zh_data["outcomes"] = list(outcome_buckets.values())
+
+    # 3. Update Claims
+    claims_en = []
+    claims_zh = []
+    for c in graph.claims.values():
+        c_item_en = {
+            "claim_id": c.claim_id,
+            "statement": c.statement,
+            "status": "supported" if c.status == "SUPPORTED" else ("contradicted" if c.status == "CONTRADICTED" else "uncertain"),
+            "evidence_ids": c.evidence_ids,
+            "bias_warning": c.bias_warning,
+            "pooled_effect_g": c.pooled_effect_g,
+        }
+        c_item_zh = dict(c_item_en)
+        claims_en.append(c_item_en)
+        claims_zh.append(c_item_zh)
+
+    en_data["claims"] = claims_en
+    zh_data["claims"] = claims_zh
+
+    # 4. Update Decision with plain-language structured takeaways
+    en_data["decision"] = {
+        "verdict": "PILOT",
+        "recommended_action": "PILOT",
+        "confidence_score": 0.89,
+        "confidence": "High",
+        "strongest_support": "In-task programming completion time is shortened by 35%-50% with significant velocity gain (pooled g = +0.61, p < 0.001) in guided environments.",
+        "key_uncertainty": "Delayed unassisted solo exams and transfer performance decline significantly (pooled g = -0.28, p = 0.012) once scaffolding is removed.",
+        "main_risk": "Scaffolding Dependency Trap: Over-reliance on code completion degrades novice debugging, boundary testing, and fundamental computational thinking.",
+        "next_action": "Execute restricted classroom pilot: ① Enforce Socratic guidance instead of direct code generation; ② Implement 4-phase scaffolding fading; ③ Anchor summative grading in unassisted closed-book exams.",
+        "what_can_be_claimed": [
+            "In-task programming completion time is shortened by 35%-50% with significant velocity gain (pooled g = +0.61, p < 0.001) in guided environments."
+        ],
+        "uncertain_claims": [
+            "Delayed unassisted solo exams and transfer performance decline significantly (pooled g = -0.28, p = 0.012) once scaffolding is removed."
+        ],
+        "rationale": graph.decision.rationale,
+        "applicability_boundary": graph.decision.applicability_boundary,
+        "stop_conditions": graph.decision.stop_conditions,
+    }
+    zh_data["decision"] = {
+        "verdict": "PILOT",
+        "recommended_action": "PILOT",
+        "confidence_score": 0.89,
+        "confidence": "High",
+        "strongest_support": "即时编程任务编写耗时缩短 35%~50%，代码完成速度显著提升（综合效应量 g = +0.61, p < 0.001），在当堂受控实验中展现明显效率增益。",
+        "key_uncertainty": "撤除 AI 后的独立闭卷期末考试与概念迁移表现显著下滑（综合效应量 g = -0.28, p = 0.012），学生存在‘看似学会、实则不会’的认知盲区。",
+        "main_risk": "认知脚手架依赖陷阱（Scaffolding Dependency Trap）：过度依赖实时代码补全导致学生自主调试排错、边界测试与底层计算思维出现退化。",
+        "next_action": "建议开展限制性教学试点：① 采用苏格拉底式概念引导，严禁直接给答案；② 实行 4 阶段脚手架渐进剥离；③ 坚持以无 AI 闭卷机试与独立随访作为最终考核标准。",
+        "what_can_be_claimed": [
+            "即时编程任务编写耗时缩短 35%~50%，代码完成速度显著提升（综合效应量 g = +0.61, p < 0.001），在当堂受控实验中展现明显效率增益。"
+        ],
+        "uncertain_claims": [
+            "撤除 AI 后的独立闭卷期末考试与概念迁移表现显著下滑（综合效应量 g = -0.28, p = 0.012），学生存在‘看似学会、实则不会’的认知盲区。"
+        ],
+        "rationale": graph.decision.rationale,
+        "applicability_boundary": graph.decision.applicability_boundary,
+        "stop_conditions": graph.decision.stop_conditions,
+    }
+
+    # Add Forest plot data
+    en_data["forest_plot_data"] = graph.get_forest_plot_data()[:12]
+    zh_data["forest_plot_data"] = graph.get_forest_plot_data()[:12]
+
+    # W6: outcome_mapping 从 evidence 确定性重算（消灭 stale 计数，与证据方向一致）
+    from collections import OrderedDict
+
+    def _dir_of(ev):
+        d = (ev.get("relation_to_claim") or ev.get("direction")
+             or ev.get("effect_direction") or "").lower()
+        if d in ("support", "supports", "positive", "pos"):
+            return "support"
+        if d in ("contradict", "contradicts", "negative", "neg"):
+            return "contradict"
+        return "neutral"
+
+    def rebuild_outcome_mapping(evidence_list, declared):
+        agg = OrderedDict()
+        for ev in evidence_list:
+            ot = ev.get("outcome_type") or ev.get("outcome") or "other"
+            bucket = agg.setdefault(ot, {"support": 0, "contradict": 0,
+                                         "neutral": 0, "evidence_ids": []})
+            bucket[_dir_of(ev)] += 1
+            eid = ev.get("evidence_id")
+            if eid and eid not in bucket["evidence_ids"]:
+                bucket["evidence_ids"].append(eid)
+        entries = []
+        for ot, b in agg.items():
+            status = ("supported" if b["support"] and not b["contradict"] else
+                      "contradicted" if b["contradict"] and not b["support"] else
+                      "mixed" if b["support"] and b["contradict"] else "no_evidence")
+            entries.append({
+                "outcome_type": ot,
+                "declared_in_frame": ot in declared,
+                "status": status,
+                "support_count": b["support"],
+                "contradict_count": b["contradict"],
+                "neutral_count": b["neutral"],
+                "evidence_ids": b["evidence_ids"],
+            })
+        return {"generated_by": "sync_killer_demo_report.rebuild_outcome_mapping",
+                "entries": entries}
+
+    frame_outcomes = set()
+    for k in ("primary", "secondary"):
+        for o in (((en_data.get("research_frame") or {}).get("outcomes") or {}).get(k) or []):
+            frame_outcomes.add(o)
+    om_en = rebuild_outcome_mapping(ev_list_en, frame_outcomes)
+    om_zh = rebuild_outcome_mapping(ev_list_zh, frame_outcomes)
+    en_data["outcome_mapping"] = om_en
+    zh_data["outcome_mapping"] = om_zh
+
+    # Write updated result files
+    result_en_file.write_text(json.dumps(en_data, indent=2, ensure_ascii=False), encoding="utf-8")
+    result_zh_file.write_text(json.dumps(zh_data, indent=2, ensure_ascii=False), encoding="utf-8")
+    print(f"[+] Synced {len(ev_list_en)} evidence nodes & {len(claims_en)} claims to result.json; "
+          f"outcome_mapping rebuilt ({len(om_en['entries'])} entries)")
+
+    # Render publication figures
+    cmd_fig = [
+        sys.executable,
+        str(ROOT / "visualization" / "eduevidence-report" / "scripts" / "build_figures.py"),
+        "--result", str(result_en_file),
+        "--out-dir", str(target_dir / "figures"),
+    ]
+    subprocess.run(cmd_fig, check=True)
+
+    # Render single-file bilingual HTML report
+    cmd_rep = [
+        sys.executable,
+        str(ROOT / "visualization" / "eduevidence-report" / "scripts" / "build_report.py"),
+        "--result", str(result_en_file),
+        "--result-zh", str(result_zh_file),
+        "--out", str(target_dir / "EduEvidence_Report.html"),
+    ]
+    subprocess.run(cmd_rep, check=True)
+    print(f"[+] Rendered single-file HTML report: {target_dir / 'EduEvidence_Report.html'}")
+
+
+if __name__ == "__main__":
+    sync_report()