eduevidence 5.2.0 → 6.2.0

package/schemas/verdict.schema.json

@@ -5,52 +5,188 @@
   "description": "Output of the Evidence Tribunal: what the evidence supports, cannot support, and the recommended action. Decision is one of ADOPT / PILOT / REJECT / INSUFFICIENT EVIDENCE (expressed here as adopt|pilot|reject|insufficient_evidence). confidence 由 scripts/compute_confidence.py 确定性计算并覆盖模型值；confidence_score 是规则化指数（0-1），不是概率。扩展字段一律放在 extensions 内。",
   "type": "object",
   "additionalProperties": false,
-  "required": ["decision_question", "recommended_action", "confidence"],
+  "required": [
+    "decision_question",
+    "recommended_action",
+    "confidence"
+  ],
   "properties": {
-    "decision_question": { "type": "string" },
-    "target_population": { "type": "string" },
-    "target_context": { "type": "string" },
-    "supported_claims": { "type": "array", "items": { "type": "string" } },
-    "uncertain_claims": { "type": "array", "items": { "type": "string" } },
-    "contradicted_claims": { "type": "array", "items": { "type": "string" } },
-    "reason_for_disagreement": { "type": "string" },
-    "methodology_summary": { "type": "string" },
-    "outcome_specific_findings": { "type": "object", "additionalProperties": true },
-    "short_term_effect": { "type": ["string", "null"] },
-    "long_term_effect": { "type": ["string", "null"] },
-    "transfer_effect": { "type": ["string", "null"] },
-    "risk_effect": { "type": ["string", "null"] },
-    "applicability": { "type": "object", "additionalProperties": true },
-    "confidence": { "type": "string", "enum": ["High", "Moderate", "Low", "Insufficient"] },
+    "decision_question": {
+      "type": "string"
+    },
+    "target_population": {
+      "type": "string"
+    },
+    "target_context": {
+      "type": "string"
+    },
+    "supported_claims": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "uncertain_claims": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "contradicted_claims": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "reason_for_disagreement": {
+      "type": "string"
+    },
+    "methodology_summary": {
+      "type": "string"
+    },
+    "outcome_specific_findings": {
+      "type": "object",
+      "additionalProperties": true
+    },
+    "short_term_effect": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "long_term_effect": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "transfer_effect": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "risk_effect": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "applicability": {
+      "type": "object",
+      "additionalProperties": true
+    },
+    "confidence": {
+      "type": "string",
+      "enum": [
+        "High",
+        "Moderate",
+        "Low",
+        "Insufficient"
+      ]
+    },
     "confidence_score": {
-      "type": ["number", "null"],
+      "type": [
+        "number",
+        "null"
+      ],
       "minimum": 0,
       "maximum": 1,
       "description": "规则化置信度指数（0-1），由 compute_confidence.py 覆盖模型值。不是概率，禁止宣传为百分比。"
     },
-    "confidence_policy_version": { "type": "string", "description": "确定性置信度策略版本号（如 2026-08-12.v1）。" },
-    "independent_studies": { "type": ["integer", "null"], "minimum": 0, "description": "独立研究数（按 study_id/source_id 去重）。" },
-    "independent_samples": { "type": ["integer", "null"], "minimum": 0, "description": "独立样本数（按 sample_id 去重）。" },
+    "confidence_policy_version": {
+      "type": "string",
+      "description": "确定性置信度策略版本号（如 2026-08-12.v1）。"
+    },
+    "independent_studies": {
+      "type": [
+        "integer",
+        "null"
+      ],
+      "minimum": 0,
+      "description": "独立研究数（按 study_id/source_id 去重）。"
+    },
+    "independent_samples": {
+      "type": [
+        "integer",
+        "null"
+      ],
+      "minimum": 0,
+      "description": "独立样本数（按 sample_id 去重）。"
+    },
     "confidence_breakdown": {
       "type": "object",
       "additionalProperties": true,
       "description": "Rule-based components: evidence_quality, consistency, directness, evidence_count, independent_studies, independent_samples, conflict_penalty, unsupported_penalty."
     },
     "raw_model_confidence": {
-      "type": ["string", "null"],
+      "type": [
+        "string",
+        "null"
+      ],
       "description": "模型原始 confidence 输出（被确定性值覆盖前的值，仅供审计比对）。"
     },
-    "raw_model_confidence_breakdown": { "type": "object", "additionalProperties": true },
-    "what_can_be_claimed": { "type": "array", "items": { "type": "string" } },
-    "what_cannot_be_claimed": { "type": "array", "items": { "type": "string" } },
-    "missing_evidence": { "type": "array", "items": { "type": "string" } },
-    "recommended_action": { "type": "string", "enum": ["adopt", "pilot", "reject", "insufficient_evidence"] },
-    "decision_rationale": { "type": "string" },
-    "exceeds_evidence_boundary": { "type": "array", "items": { "type": "string" }, "description": "Conclusions that currently go beyond the evidence boundary." },
+    "raw_model_confidence_breakdown": {
+      "type": "object",
+      "additionalProperties": true
+    },
+    "what_can_be_claimed": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "what_cannot_be_claimed": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "missing_evidence": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "recommended_action": {
+      "type": "string",
+      "enum": [
+        "adopt",
+        "pilot",
+        "reject",
+        "insufficient_evidence"
+      ]
+    },
+    "decision_rationale": {
+      "type": "string"
+    },
+    "exceeds_evidence_boundary": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Conclusions that currently go beyond the evidence boundary."
+    },
     "extensions": {
       "type": "object",
       "description": "结构化扩展字段的统一容器（P1-01）。未列入本 schema 的字段必须放在这里，禁止在顶层新增属性。",
       "additionalProperties": true
+    },
+    "strongest_support": {
+      "type": "string",
+      "description": "The single strongest conclusion the evidence supports, as a complete reader-facing sentence (<=60 chars zh / ~15 words en). Written by the adjudicator, not assembled by the renderer."
+    },
+    "key_uncertainty": {
+      "type": "string",
+      "description": "The decision-relevant uncertainty or counter-evidence, as a complete reader-facing sentence (<=70 chars zh / ~18 words en)."
+    },
+    "main_risk": {
+      "type": "string",
+      "description": "The principal risk of acting, as a complete reader-facing sentence (<=60 chars zh / ~15 words en)."
+    },
+    "next_action": {
+      "type": "string",
+      "description": "The recommended next step, as a complete reader-facing sentence (<=80 chars zh / ~20 words en)."
     }
   }
 }

package/scripts/benchmark_judge.py

@@ -45,7 +45,7 @@ from benchmark_evaluator import extract_json_block  # noqa: E402
 
 JUDGE_DIMS = ("citation_support", "outcome_correctness", "scope_calibration",
               "contradiction_handling", "decision_calibration")
-DEFAULT_JUDGE_MODEL = "deepseek-v4-flash"
+DEFAULT_JUDGE_MODEL = ""  # 无默认：judge 模型必须显式指定或经 EDUEVIDENCE_LLM_MODEL 提供
 DEFAULT_LIMIT = 60
 HEURISTIC_METRICS = ("outcome_separation_accuracy", "decision_calibration",
                      "contradiction_recall", "contradiction_precision",
@@ -514,7 +514,7 @@ def main(argv: list[str] | None = None) -> int:
     p_run.add_argument("--questions", default="benchmarks/questions.jsonl")
     p_run.add_argument("--annotations", default="benchmarks/annotations")
     p_run.add_argument("--model", default=DEFAULT_JUDGE_MODEL)
-    p_run.add_argument("--thinking", default="minimal")
+    p_run.add_argument("--thinking", default="max", choices=["low", "high", "max"])
     p_run.add_argument("--limit", type=int, default=DEFAULT_LIMIT,
                        help="max completed attempts to judge (default 60; <=0 = unlimited)")
     p_run.set_defaults(func=_cmd_run)

package/scripts/benchmark_v3.py

@@ -31,6 +31,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import subprocess
 import sys
 import urllib.error
 import urllib.request
@@ -48,8 +49,6 @@ BASELINES = (
 )
 DEFAULT_BUDGET_TOKENS = 1_000_000
 
-# ---------------------------------------------------------------- prompts
-
 
 def _prompt_b0(q: dict) -> str:
     return (
@@ -118,9 +117,6 @@ def build_prompt(baseline: str, q: dict) -> str:
     return fn(q)
 
 
-# ---------------------------------------------------------------- drivers
-
-
 class ApiDriver:
     """OpenAI-compatible chat completions driver (no SDK dependency)."""
 
@@ -152,7 +148,7 @@ class ApiDriver:
             headers={"Content-Type": "application/json",
                      "Authorization": f"Bearer {self.api_key}"},
             method="POST")
-        with urllib.request.urlopen(req, timeout=self.timeout) as resp:  # noqa: S310 (user-configured endpoint)
+        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
             payload = json.loads(resp.read().decode("utf-8"))
         usage = payload.get("usage") or {}
         text = (payload.get("choices") or [{}])[0].get("message", {}).get("content", "")
@@ -166,28 +162,21 @@ class ApiDriver:
 
 
 class CliDriver:
-    """omp CLI driver - host agent runtime (user-approved).
-
-    Calls `omp -p --no-session --model=<model> <prompt>` in a scratch dir;
-    captures stdout as the response. Token usage is estimated from text
-    length and recorded as such (manifest usage fields may stay null; the
-    run manifest environment records the exact invocation).
-    """
+    """omp CLI driver - host agent runtime (user-approved)."""
 
     name = "cli"
 
-    def __init__(self, model: str | None = None, thinking: str = "minimal",
+    def __init__(self, model: str | None = None, thinking: str = "max",
                  timeout: int = 600):
-        self.model = model or os.environ.get("EDUEVIDENCE_LLM_MODEL", "deepseek-v4-flash")
+        self.model = model or os.environ.get("EDUEVIDENCE_LLM_MODEL", "")
         self.thinking = thinking
         self.timeout = timeout
 
     def available(self) -> bool:
         import shutil
-        return shutil.which("omp") is not None
+        return bool(self.model) and shutil.which("omp") is not None
 
     def call(self, prompt: str, *, no_tools: bool = False) -> tuple[str, dict]:
-        import subprocess
         import tempfile
         import time
 
@@ -200,7 +189,7 @@ class CliDriver:
         t0 = time.monotonic()
         with tempfile.TemporaryDirectory(prefix="eduevidence-bench-") as workdir:
             proc = subprocess.run(cmd, capture_output=True, text=True,
-                                 timeout=self.timeout, cwd=workdir)
+                                  timeout=self.timeout, cwd=workdir)
         latency = time.monotonic() - t0
         if proc.returncode != 0:
             raise RuntimeError(
@@ -214,6 +203,7 @@ class CliDriver:
         }
         return text, usage
 
+
 class SimDriver:
     """Deterministic simulation — harness validation ONLY. Never performance evidence."""
 
@@ -226,10 +216,8 @@ class SimDriver:
         return True
 
     def call(self, prompt: str, *, no_tools: bool = False) -> tuple[str, dict[str, Any]]:
-        from benchmark_v2 import simulate_question_result  # noqa: PLC0415
+        from benchmark_v2 import simulate_question_result  # noqa: F401
 
-        # Deterministic pseudo-usage from prompt length; response is a stub
-        # that the evaluator must never use as model performance.
         import random
         rng = random.Random(len(prompt) * 7919 % 2**31)
         usage = {
@@ -246,28 +234,26 @@ class SimDriver:
         )
 
 
-def make_driver(name: str) -> Any:
+def make_driver(name: str, *, model: str | None = None, thinking: str = "max") -> Any:
     if name == "api":
         return ApiDriver()
     if name == "cli":
-        return CliDriver()
+        return CliDriver(model=model, thinking=thinking)
     if name == "sim":
         return SimDriver()
     raise ValueError(f"unknown driver: {name}")
 
 
-# ---------------------------------------------------------------- run
-
-
 def _now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
 def run_benchmark(*, questions: list[dict], baselines: list[str], repeats: int,
                   out_dir: Path, driver_name: str, budget_tokens: int | None,
-                  temperature: float = 0.0, resume: bool = False) -> dict[str, Any]:
+                  temperature: float = 0.0, resume: bool = False,
+                  model: str | None = None, thinking: str = "max") -> dict[str, Any]:
     out_dir.mkdir(parents=True, exist_ok=True)
-    driver = make_driver(driver_name)
+    driver = make_driver(driver_name, model=model, thinking=thinking)
     if not driver.available():
         raise RuntimeError(
             f"driver '{driver_name}' unavailable (api needs EDUEVIDENCE_LLM_MODEL "
@@ -303,8 +289,6 @@ def run_benchmark(*, questions: list[dict], baselines: list[str], repeats: int,
     total_tokens = 0
     budget_stopped = False
     import re as _re
-    # --resume: reuse previously completed attempts (their response artifacts
-    # live in out_dir); only unfinished attempts are re-run.
     done_ids: set[str] = set()
     resumed: dict[str, dict[str, Any]] = {}
     if resume and out_dir.is_dir():
@@ -315,7 +299,7 @@ def run_benchmark(*, questions: list[dict], baselines: list[str], repeats: int,
             except (OSError, _json.JSONDecodeError):
                 continue
             aid = data.get("attempt_id")
-            if aid and (out_dir / art.name).is_file():
+            if aid and art.is_file():
                 done_ids.add(aid)
                 resumed[aid] = data
         if done_ids:
@@ -333,9 +317,6 @@ def run_benchmark(*, questions: list[dict], baselines: list[str], repeats: int,
                     break
                 attempt_id = f"{question['id']}-{baseline}-a{attempt}"
                 if attempt_id in done_ids:
-                    # Re-register resumed attempts in the manifest (status +
-                    # usage read back from their artifact) so eval/report see
-                    # the complete run.
                     art = out_dir / f"{attempt_id}.response.json"
                     data = resumed.get(attempt_id, {})
                     usage = data.get("usage") or {}
@@ -393,7 +374,7 @@ def run_benchmark(*, questions: list[dict], baselines: list[str], repeats: int,
                     }, ensure_ascii=False, indent=2), encoding="utf-8")
                     entry["artifacts"] = [artifact.name]
                 except (urllib.error.URLError, OSError, ValueError, KeyError,
-                        subprocess.TimeoutExpired) as exc:  # P2-1: a hung model call must not kill the whole run
+                        subprocess.TimeoutExpired) as exc:
                     entry.update({"status": "failed", "error": str(exc),
                                   "finished_at": _now_iso()})
                 manifest["attempts"].append(entry)
@@ -405,8 +386,6 @@ def run_benchmark(*, questions: list[dict], baselines: list[str], repeats: int,
                     break
 
     if budget_stopped:
-        # P2-2: record remaining attempts as budget_stopped so the report can
-        # distinguish "stopped by budget" from "never scheduled".
         for question in questions:
             if any(a["question_id"] == question["id"] for a in manifest["attempts"]):
                 continue
@@ -429,7 +408,7 @@ def run_benchmark(*, questions: list[dict], baselines: list[str], repeats: int,
     tmp = out_dir / "manifest.json.tmp"
     tmp.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
                    encoding="utf-8")
-    tmp.replace(manifest_path)  # atomic write (P2-4)
+    tmp.replace(manifest_path)
     _validate_manifest(manifest_path)
     print(f"wrote {manifest_path} (attempts={len(manifest['attempts'])}, "
           f"mode={manifest['run_mode']}, total_tokens~{total_tokens})")
@@ -444,13 +423,13 @@ def _questions_version() -> str:
         proc = _sp.run(["git", "-C", str(repo), "rev-parse", "--short", "HEAD"],
                        capture_output=True, text=True, timeout=10)
         return proc.stdout.strip() or "unknown"
-    except Exception:  # noqa: BLE001 - version lookup must never fail a run
+    except Exception:
         return "unknown"
 
 
 def _validate_manifest(path: Path) -> None:
     sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-    from validate_schema import Validator, SchemaError  # noqa: PLC0415
+    from validate_schema import Validator, SchemaError
 
     import json as _json
     schema = _json.loads(
@@ -479,12 +458,12 @@ def _cmd_run(args: argparse.Namespace) -> int:
         baselines=baselines, repeats=args.repeats,
         out_dir=Path(args.out), driver_name=args.driver,
         budget_tokens=args.budget_tokens, temperature=args.temperature,
-        resume=args.resume)
+        resume=args.resume, model=args.model, thinking=args.thinking)
     return 0
 
 
 def _cmd_report(args: argparse.Namespace) -> int:
-    from benchmark_evaluator import report_from_run  # noqa: PLC0415
+    from benchmark_evaluator import report_from_run
 
     run_dir = Path(args.run)
     manifest = json.loads((run_dir / "manifest.json").read_text(encoding="utf-8"))
@@ -508,6 +487,10 @@ def main(argv: list[str] | None = None) -> int:
     p_run.add_argument("--out", required=True)
     p_run.add_argument("--budget-tokens", type=int, default=DEFAULT_BUDGET_TOKENS)
     p_run.add_argument("--temperature", type=float, default=0.0)
+    p_run.add_argument("--model", default="",
+                       help="OMP model for --driver cli (required; env EDUEVIDENCE_LLM_MODEL accepted; no unconfirmed default)")
+    p_run.add_argument("--thinking", default="max", choices=["low", "high", "max"],
+                       help="reasoning effort for --driver cli")
     p_run.add_argument("--resume", action="store_true",
                        help="skip attempts whose response artifacts already exist in --out")
     p_run.set_defaults(func=_cmd_run)
@@ -536,7 +519,7 @@ def main(argv: list[str] | None = None) -> int:
 
 
 def _cmd_eval(args: argparse.Namespace) -> int:
-    from benchmark_evaluator import evaluate_run  # noqa: PLC0415
+    from benchmark_evaluator import evaluate_run
 
     run_dir = Path(args.run)
     manifest = json.loads((run_dir / "manifest.json").read_text(encoding="utf-8"))

package/scripts/build_esl_artifacts.py

@@ -10,7 +10,7 @@ import sys
 from pathlib import Path
 
 # Add project root to sys.path
-BASE_DIR = Path("/Users/cc/edu").resolve()
+BASE_DIR = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(BASE_DIR))
 
 from engine.evidence_graph import (
@@ -18,7 +18,7 @@ from engine.evidence_graph import (
     ClaimNode, RiskNode, GapNode, DecisionNode, GraphEdge
 )
 
-ESL_DIR = BASE_DIR / "examples" / "esl-academic-writing-ai"
+ESL_DIR = BASE_DIR / "tests" / "fixtures" / "legacy-examples" / "esl-academic-writing-ai"
 ESL_DIR.mkdir(parents=True, exist_ok=True)
 THEMES_DIR = ESL_DIR / "reports-5themes"
 THEMES_DIR.mkdir(parents=True, exist_ok=True)
@@ -1552,7 +1552,7 @@ result_en = {
         "complexity": "L",
         "mode": "agent_mcp_enhanced",
         "agents": [
-            "education-planner",
+            "research-planner",
             "evidence-retriever",
             "evidence-analyst",
             "skeptic",
@@ -1651,7 +1651,7 @@ result_zh = {
         "complexity": "L",
         "mode": "agent_mcp_enhanced",
         "agents": [
-            "education-planner",
+            "research-planner",
             "evidence-retriever",
             "evidence-analyst",
             "skeptic",

package/scripts/build_evidence_library.py

@@ -59,8 +59,8 @@ ANNOTATIONS_DIR = ROOT / "benchmarks" / "annotations"
 QUESTIONS_PATH = ROOT / "benchmarks" / "questions.jsonl"
 EXAMPLE_EVIDENCE = {
     "ai-coding-assistant": ROOT / "examples" / "ai-coding-assistant" / "evidence.jsonl",
-    "ai-tutor": ROOT / "examples" / "ai-tutor" / "evidence.jsonl",
-    "ai-writing-assistant": ROOT / "examples" / "ai-writing-assistant" / "evidence.jsonl",
+    "ai-tutor": ROOT / "tests" / "fixtures" / "legacy-examples" / "ai-tutor" / "evidence.jsonl",
+    "ai-writing-assistant": ROOT / "tests" / "fixtures" / "legacy-examples" / "ai-writing-assistant" / "evidence.jsonl",
 }
 
 _WS_RE = re.compile(r"\s+")

package/scripts/build_gh_pages.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""Build public Pages: unchanged introduction + read-only example Studio.
+
+Only repository examples are exported. The user's EDUEVIDENCE_HOME, local
+projects, run events and Autoevolve session data never enter this artifact.
+"""
+from __future__ import annotations
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+WEB_DIR = ROOT / 'web'
+EXAMPLES_DIR = ROOT / 'examples'
+OUT_DIR = ROOT / 'dist_gh_pages'
+sys.path.insert(0, str(ROOT))
+from engine.studio_read_model import StudioReader  # noqa: E402
+from scripts.build_report_variants import bake  # noqa: E402
+from scripts.dashboard_server import scan_local_projects, build_stats, build_viz_payload  # noqa: E402
+
+
+def write_json(path: Path, payload):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, ensure_ascii=False, allow_nan=False, indent=2), encoding='utf-8')
+
+
+def main():
+    if not (WEB_DIR / 'studio' / 'index.html').is_file():
+        raise SystemExit('Build the frontend first: cd studio && npm ci && npm run build')
+    bake(EXAMPLES_DIR)
+    if OUT_DIR.exists():
+        shutil.rmtree(OUT_DIR)
+    OUT_DIR.mkdir(parents=True)
+    for item in WEB_DIR.iterdir():
+        if item.name == 'api':
+            continue
+        if item.is_dir():
+            shutil.copytree(item, OUT_DIR / item.name, dirs_exist_ok=True)
+        else:
+            shutil.copy2(item, OUT_DIR / item.name)
+
+    # Legacy landing endpoints kept without modifying source web/api artifacts.
+    projects = scan_local_projects()
+    for project in projects:
+        name = project['id']
+        project['html_report_path'] = f'reports/{name}/EduEvidence_Report.html' if project.get('html_report_path') else None
+        for variant in project.get('report_variants', []):
+            variant['path'] = f"reports/{name}/{Path(variant['path']).name}"
+    write_json(OUT_DIR / 'api' / 'projects.json', {'projects': projects, 'stats': build_stats(projects)})
+    for project in projects:
+        write_json(OUT_DIR / 'api' / 'projects' / project['id'] / 'viz.json', build_viz_payload(project['id']))
+
+    reader = StudioReader(EXAMPLES_DIR, ROOT / '.static-export-no-local-state', static=True)
+    catalog = reader.catalog()
+    write_json(OUT_DIR / 'api' / 'studio' / 'catalog.json', catalog)
+    write_json(OUT_DIR / 'api' / 'studio' / 'evolution.json', {'experiments': [], 'status': 'not_exported'})
+    for project in catalog['projects']:
+        key = project['id']
+        detail = reader.detail(key)
+        write_json(OUT_DIR / 'api' / 'studio' / 'projects' / f'{key}.json', detail)
+        name = key.removeprefix('example--')
+        source = EXAMPLES_DIR / name
+        target = OUT_DIR / 'reports' / name
+        target.mkdir(parents=True, exist_ok=True)
+        for path in (source / 'reports-5themes').glob('*.html'):
+            shutil.copy2(path, target / path.name)
+        current_default = source / 'reports-5themes' / 'EduEvidence_Report_claude.html'
+        if not current_default.exists():
+            current_default = source / 'EduEvidence_Report.html'
+        if current_default.is_file():
+            shutil.copy2(current_default, target / 'EduEvidence_Report.html')
+    write_json(OUT_DIR / 'studio' / 'config.json', {'mode': 'static', 'api_base': '../api/studio', 'readonly': True})
+    # Keep old public entry links functional without changing the landing design.
+    redirect = '<!doctype html><html lang="en"><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=./studio/"><title>Research Studio</title><a href="./studio/">Open Research Studio</a><script>location.replace("./studio/"+location.hash)</script></html>'
+    (OUT_DIR / 'studio.html').write_text(redirect, encoding='utf-8')
+    landing = WEB_DIR / 'landing.html'
+    if landing.is_file():
+        page = landing.read_text(encoding='utf-8')
+        page = page.replace('href="/landing.html"', 'href="index.html"').replace('href="/index.html"', 'href="studio/"')
+        theme_alias = {'claude_research':'claude', 'academic_paper':'academic', 'datalab_light':'datalab', 'datalab_dark':'datalab-dark', 'presentation_judge':'presentation'}
+        def report_link(match):
+            parts = match.group(1).replace('&amp;', '&').split('&')
+            project_id = parts[0]
+            theme = next((s.split('=', 1)[1] for s in parts[1:] if s.startswith('theme=')), 'default')
+            theme = theme_alias.get(theme, theme)
+            filename = 'EduEvidence_Report.html' if theme == 'default' else f'EduEvidence_Report_{theme}.html'
+            return f'href="reports/{project_id}/{filename}"'
+        page = re.sub(r'href="/report\?id=([^\"]+)"', report_link, page)
+        (OUT_DIR / 'index.html').write_text(page, encoding='utf-8')
+        (OUT_DIR / 'landing.html').write_text(page, encoding='utf-8')
+    (OUT_DIR / '.nojekyll').write_text('', encoding='utf-8')
+    print(f'Pages ready: {len(catalog["projects"])} public cases; local projects excluded')
+
+
+if __name__ == '__main__':
+    main()