eduevidence 5.2.0 → 6.2.0

package/scripts/research_auto_cli.py

@@ -0,0 +1,475 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shlex
+import subprocess
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def _read_json(path: str | Path | None, default=None):
+    if not path:
+        return default
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def _write_json(path: Path, value: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def _home(value):
+    if value:
+        return Path(value).expanduser().resolve()
+    from engine.paths import resolve_home
+    return resolve_home()
+
+
+def _project(home, project_id):
+    from engine.project import ProjectWorkspace
+    return ProjectWorkspace.open(home, project_id)
+
+
+def _load_gaps(workspace, explicit=None):
+    if explicit:
+        path = Path(explicit)
+        rows = [
+            json.loads(line)
+            for line in path.read_text(encoding="utf-8").splitlines()
+            if line.strip()
+        ]
+    else:
+        gap_dir = workspace.path / "gaps"
+        files = sorted(gap_dir.glob("gaps-rev-*.jsonl")) if gap_dir.exists() else []
+        if not files:
+            raise ValueError("no persisted KnowledgeGap file; derive gaps first or pass --gaps")
+        rows = [
+            json.loads(line)
+            for line in files[-1].read_text(encoding="utf-8").splitlines()
+            if line.strip()
+        ]
+    return rows
+
+
+def _apply_gap_state(gaps: list[dict[str, Any]], state: dict[str, str]) -> None:
+    for gap in gaps:
+        gap_id = str(gap.get("gap_id", ""))
+        if gap_id in state:
+            gap["status"] = state[gap_id]
+
+
+def _save_gap_state(path: Path, gaps: list[dict[str, Any]]) -> None:
+    _write_json(
+        path,
+        {
+            str(gap.get("gap_id")): str(gap.get("status", "open"))
+            for gap in gaps
+            if gap.get("gap_id")
+        },
+    )
+
+
+def _require_fresh_research_state(
+    *,
+    active_revision: int,
+    gaps: list[dict[str, Any]],
+    decision: dict[str, Any],
+    previous_state: dict[str, Any],
+) -> None:
+    if previous_state.get("next_action") == "re_adjudicate":
+        if int(decision.get("graph_revision", -1)) != active_revision:
+            raise ValueError(
+                "re-adjudication barrier: provide a DecisionSnapshot bound to the current GraphRevision"
+            )
+    for gap in gaps:
+        derived = gap.get("derived_from_graph_revision")
+        if derived is not None and int(derived) != active_revision:
+            raise ValueError(
+                f"stale KnowledgeGap {gap.get('gap_id')}: derived from revision {derived}, "
+                f"active revision is {active_revision}; re-derive gaps before continuing"
+            )
+
+
+def _iteration_id(iteration_number: int) -> str:
+    return f"RIT-{iteration_number:04d}"
+
+
+def _request(priority, strategy, project_id, revision, iteration_number, gap):
+    iteration_id = _iteration_id(iteration_number)
+    return {
+        "project_id": project_id,
+        "iteration_id": iteration_id,
+        "iteration_number": iteration_number,
+        "base_graph_revision": revision,
+        "gap_id": priority.gap_id,
+        "gap": gap,
+        "gap_priority": priority.as_dict(),
+        "strategy": {
+            "strategy_id": strategy.strategy_id,
+            "experiment_type": strategy.experiment_type.value,
+            "hypothesis": strategy.hypothesis,
+            "expected_gain": strategy.expected_gain,
+            "budget": strategy.budget.__dict__,
+        },
+        "contract": {
+            "canonical_state_write": "FORBIDDEN",
+            "output": "validated staging result JSON only",
+            "required_measurements": ["query_count", "candidate_count", "fetched_count"],
+            "negative_search_research_iteration_id": iteration_id,
+            "negative_search_gap_id": priority.gap_id,
+            "search_snippets_are_evidence": False,
+        },
+    }
+
+
+def _validate_outcome_budget(outcome: dict[str, Any], strategy) -> None:
+    if not isinstance(outcome, dict):
+        raise ValueError("executor output must be a JSON object")
+    budget = strategy.budget
+    checks = (
+        ("query_count", budget.max_queries),
+        ("candidate_count", budget.max_candidates),
+        ("fetched_count", budget.max_fulltext_fetches),
+    )
+    measured: dict[str, int] = {}
+    for key, limit in checks:
+        if key not in outcome:
+            raise ValueError(f"executor output must report {key} to enforce bounded research")
+        try:
+            value = int(outcome[key])
+        except (TypeError, ValueError) as exc:
+            raise ValueError(f"executor measurement {key} must be an integer") from exc
+        if value < 0:
+            raise ValueError(f"executor measurement {key} cannot be negative")
+        if value > limit:
+            raise ValueError(f"research budget exceeded: {key}={value} > {limit}")
+        measured[key] = value
+    if measured["fetched_count"] > measured["candidate_count"]:
+        raise ValueError("fetched_count cannot exceed candidate_count")
+    candidates = outcome.get("candidate_sources")
+    if isinstance(candidates, list) and len(candidates) > measured["candidate_count"]:
+        raise ValueError("candidate_sources length exceeds reported candidate_count")
+    attempts = outcome.get("search_attempts")
+    if isinstance(attempts, list) and len(attempts) > measured["query_count"]:
+        raise ValueError("search_attempts length exceeds reported query_count")
+
+
+def _validate_outcome_identity(
+    outcome: dict[str, Any], *, expected_iteration_id: str, expected_gap_id: str
+) -> None:
+    supplied_iteration = outcome.get("iteration_id")
+    supplied_gap = outcome.get("gap_id")
+    if supplied_iteration is not None and supplied_iteration != expected_iteration_id:
+        raise ValueError("executor iteration_id does not match ResearchRequest")
+    if supplied_gap is not None and supplied_gap != expected_gap_id:
+        raise ValueError("executor gap_id does not match ResearchRequest")
+
+
+def _external_executor(command, request, request_path, *, timeout_seconds: int):
+    _write_json(request_path, request)
+    argv = shlex.split(command)
+    if not argv:
+        raise ValueError("empty executor command")
+    env = os.environ.copy()
+    env["EDUEVIDENCE_RESEARCH_REQUEST"] = str(request_path)
+    completed = subprocess.run(
+        argv,
+        check=True,
+        text=True,
+        capture_output=True,
+        env=env,
+        timeout=timeout_seconds,
+    )
+    value = json.loads(completed.stdout)
+    if not isinstance(value, dict):
+        raise ValueError("executor stdout must be one JSON object")
+    return value
+
+
+def _commit_payload(workspace, run_id, payload, *, expected_base_revision: int):
+    from engine.autoresearch import commit_staging_bundle
+    from engine.graph_store import GraphStore
+
+    return commit_staging_bundle(
+        GraphStore.create(workspace),
+        run_id=run_id,
+        expected_base_revision=expected_base_revision,
+        payload=payload,
+    )
+
+
+@contextmanager
+def _writer_lock(path: Path):
+    """One research-auto writer per Project; stale locks fail closed."""
+    payload = {
+        "pid": os.getpid(),
+        "acquired_at": datetime.now(timezone.utc).isoformat(),
+    }
+    flags = os.O_CREAT | os.O_EXCL | os.O_WRONLY
+    try:
+        fd = os.open(path, flags, 0o600)
+    except FileExistsError as exc:
+        detail = ""
+        try:
+            detail = path.read_text(encoding="utf-8").strip()
+        except OSError:
+            pass
+        raise RuntimeError(
+            f"research auto writer already active or a stale lock exists at {path}. "
+            "Do not delete it while another run is active; after confirming no writer is running, "
+            f"remove it manually. lock={detail or 'unreadable'}"
+        ) from exc
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle)
+            handle.write("\n")
+        yield
+    finally:
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def _mutating_research_auto(args, workspace, root, state_path, gap_state_path, stop_path):
+    from engine.autoresearch import EvidenceAutoresearchController, NegativeSearchRecord, ResearchMemory
+    from engine.graph_store import GraphStore
+
+    memory = ResearchMemory(root)
+    gaps = _load_gaps(workspace, args.gaps)
+    _apply_gap_state(gaps, _read_json(gap_state_path, {}) or {})
+    decision = _read_json(args.decision, {}) or {}
+    controller = EvidenceAutoresearchController(max_iterations=args.max_iterations)
+    store = GraphStore.create(workspace)
+    previous_state = _read_json(state_path, {}) or {}
+    _require_fresh_research_state(
+        active_revision=store.active_revision(),
+        gaps=gaps,
+        decision=decision,
+        previous_state=previous_state,
+    )
+
+    def process(outcome, history, priority, strategy):
+        base_revision = GraphStore.create(workspace).active_revision()
+        expected_iteration_id = _iteration_id(len(history) + 1)
+        _validate_outcome_identity(
+            outcome,
+            expected_iteration_id=expected_iteration_id,
+            expected_gap_id=priority.gap_id,
+        )
+        _validate_outcome_budget(outcome, strategy)
+        evidence_ids = outcome.get("validated_evidence_ids") or [
+            item.get("finding_id")
+            for item in outcome.get("findings", [])
+            if isinstance(item, dict) and item.get("finding_id")
+        ]
+        outcome["validated_evidence_ids"] = [item for item in evidence_ids if item]
+
+        def executor(actual_strategy, gap):
+            if actual_strategy.strategy_id != strategy.strategy_id:
+                raise RuntimeError("controller strategy changed between request and execution")
+            return outcome
+
+        def commit(_ids):
+            return _commit_payload(
+                workspace,
+                f"autoresearch-{len(history) + 1:04d}",
+                outcome,
+                expected_base_revision=base_revision,
+            )
+
+        result = controller.step(
+            project_id=args.project,
+            base_graph_revision=base_revision,
+            gaps=gaps,
+            decision=decision,
+            history=history,
+            executor=executor,
+            graph_commit=commit if outcome["validated_evidence_ids"] else None,
+            ethics_feasible=args.ethics_feasible,
+        )
+        for raw in outcome.get("negative_searches", []):
+            record = NegativeSearchRecord(**raw)
+            if record.research_iteration_id != result.iteration.iteration_id:
+                raise ValueError(
+                    "NegativeSearchRecord research_iteration_id does not match current iteration"
+                )
+            if record.gap_id != result.iteration.gap_id:
+                raise ValueError("NegativeSearchRecord gap_id does not match current gap")
+            memory.append_negative_search(record)
+            if record.negative_search_id not in result.iteration.negative_search_ids:
+                result.iteration.negative_search_ids.append(record.negative_search_id)
+        memory.append_iteration(result.iteration)
+        return result
+
+    def persist_result(result, completed=None):
+        selected = next(g for g in gaps if g.get("gap_id") == result.iteration.gap_id)
+        if result.next_action == "stop_search_saturated":
+            selected["status"] = "search_saturated"
+        elif result.next_action == "empirical_evidence_needed":
+            selected["status"] = "empirical_needed"
+        state = {
+            "status": result.iteration.status.value if result.iteration.status else "unknown",
+            "next_action": result.next_action,
+            "gap_priority": result.priority.as_dict(),
+            "iteration": result.iteration.as_dict(),
+            "rationale": list(result.rationale),
+        }
+        if completed is not None:
+            state["completed_iterations"] = list(completed)
+        _save_gap_state(gap_state_path, gaps)
+        _write_json(state_path, state)
+        return state
+
+    if args.action == "step":
+        history = memory.load_iterations()
+        priority = controller.select_gap(gaps, decision)
+        gap = next(g for g in gaps if g.get("gap_id") == priority.gap_id)
+        strategy = controller.build_strategy(priority, gap, history)
+        outcome = _read_json(args.outcome_file) if args.outcome_file else None
+        if outcome is None:
+            pending = {
+                "status": "awaiting_execution",
+                **_request(
+                    priority,
+                    strategy,
+                    args.project,
+                    GraphStore.create(workspace).active_revision(),
+                    len(history) + 1,
+                    gap,
+                ),
+            }
+            _write_json(state_path, pending)
+            print(json.dumps(pending, ensure_ascii=False, indent=2))
+            return 0
+        result = process(outcome, history, priority, strategy)
+        state = persist_result(result)
+        print(json.dumps(state, ensure_ascii=False, indent=2))
+        return 0
+
+    if args.outcome_file and args.max_iterations != 1:
+        raise ValueError(
+            "--outcome-file with start requires --max-iterations 1; use --executor-command for a loop"
+        )
+    if not args.executor_command and not args.outcome_file:
+        raise ValueError(
+            "start requires --executor-command or one --outcome-file with --max-iterations 1"
+        )
+
+    completed = []
+    for _ in range(args.max_iterations):
+        if stop_path.exists():
+            stop_path.unlink(missing_ok=True)
+            latest = _read_json(state_path, {}) or {}
+            latest["status"] = "stopped_by_user"
+            latest["completed_iterations"] = list(completed)
+            _write_json(state_path, latest)
+            break
+        history = memory.load_iterations()
+        priority = controller.select_gap(gaps, decision)
+        gap = next(g for g in gaps if g.get("gap_id") == priority.gap_id)
+        strategy = controller.build_strategy(priority, gap, history)
+        request = _request(
+            priority,
+            strategy,
+            args.project,
+            GraphStore.create(workspace).active_revision(),
+            len(history) + 1,
+            gap,
+        )
+        outcome = (
+            _read_json(args.outcome_file)
+            if args.outcome_file
+            else _external_executor(
+                args.executor_command,
+                request,
+                root / f"request-{len(history) + 1:04d}.json",
+                timeout_seconds=args.executor_timeout_seconds,
+            )
+        )
+        result = process(outcome, history, priority, strategy)
+        completed.append(result.iteration.iteration_id)
+        persist_result(result, completed)
+
+        if result.next_action in {
+            "re_adjudicate",
+            "empirical_evidence_needed",
+            "stop_search_saturated",
+        }:
+            break
+        if all(str(row.get("status", "")).lower() == "resolved" for row in gaps):
+            break
+
+    final = _read_json(state_path, {"status": "completed_no_iterations"})
+    print(json.dumps(final, ensure_ascii=False, indent=2))
+    return 0
+
+
+def research_auto(argv):
+    parser = argparse.ArgumentParser(prog="eduevidence research auto")
+    sub = parser.add_subparsers(dest="action", required=True)
+    for name in ("step", "start"):
+        cmd = sub.add_parser(name)
+        cmd.add_argument("--project", required=True)
+        cmd.add_argument("--home")
+        cmd.add_argument("--gaps")
+        cmd.add_argument("--decision")
+        cmd.add_argument("--outcome-file")
+        cmd.add_argument("--max-iterations", type=int, default=5)
+        cmd.add_argument("--ethics-feasible", action="store_true")
+        cmd.add_argument("--executor-timeout-seconds", type=int, default=1800)
+        if name == "start":
+            cmd.add_argument("--executor-command")
+    for name in ("status", "report", "stop"):
+        cmd = sub.add_parser(name)
+        cmd.add_argument("--project", required=True)
+        cmd.add_argument("--home")
+    args = parser.parse_args(argv)
+    if getattr(args, "executor_timeout_seconds", 1) <= 0:
+        raise ValueError("executor timeout must be positive")
+
+    workspace = _project(_home(args.home), args.project)
+    root = workspace.path / "autoresearch"
+    root.mkdir(parents=True, exist_ok=True)
+    state_path = root / "state.json"
+    gap_state_path = root / "gap-state.json"
+    stop_path = root / "stop.requested"
+    lock_path = root / ".writer.lock"
+
+    if args.action in {"status", "report"}:
+        state = _read_json(state_path, {"status": "not_started"})
+        if isinstance(state, dict):
+            state = dict(state)
+            state["stop_requested"] = stop_path.exists()
+            state["writer_active"] = lock_path.exists()
+        print(json.dumps(state, ensure_ascii=False, indent=2))
+        return 0
+    if args.action == "stop":
+        stop_path.write_text(
+            json.dumps(
+                {
+                    "requested_at": datetime.now(timezone.utc).isoformat(),
+                    "requested_by_pid": os.getpid(),
+                }
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        print("stop requested")
+        return 0
+
+    with _writer_lock(lock_path):
+        return _mutating_research_auto(
+            args,
+            workspace,
+            root,
+            state_path,
+            gap_state_path,
+            stop_path,
+        )

package/scripts/run_workspace.py

@@ -46,14 +46,16 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-SKILL_VERSION = "1.0.0"
+from engine.versions import CONFIDENCE_POLICY_VERSION, ENGINE_VERSION
+from engine.workflows import execution_stages
+
+# Kept as an import-compatible name for existing integrations.  Engine version
+# is the sole source of truth for new manifests.
+SKILL_VERSION = ENGINE_VERSION
 RESOURCE_POLICY_VERSION = "2026-08-12.v1"
 
 #: Ordered EvidenceFlow stages the orchestrator routes through.
-STAGES = [
-    "frame", "retrieve", "extract", "challenge", "audit",
-    "adjudicate", "intervene", "evaluate", "present",
-]
+STAGES = list(execution_stages())
 
 #: Every artifact a run workspace owns (dirs end with '/').
 WORKSPACE_FILES: list[str] = [
@@ -61,7 +63,7 @@ WORKSPACE_FILES: list[str] = [
     "capability_plan.json", "resource_plan.json", "execution_plan.json",
     "model_inventory.json", "agent_mcp_approval.json",
     "frame.json", "sources.jsonl", "fetch/", "evidence.jsonl", "skeptic.json",
-    "methodology.json", "raw_verdict.json", "final_verdict.json",
+    "methodology.json", "raw_verdict.json", "final_verdict.json", "applicability.json",
     "intervention.json", "evaluation.json", "result.json", "result.zh.json",
     "report_spec.json", "report.html", "trace.jsonl",
 ]
@@ -77,6 +79,7 @@ EMPTY_SEED: dict[str, str] = {
     "evidence.jsonl": "",
     "skeptic.json": "{}",
     "methodology.json": "{}",
+    "applicability.json": "{}",
     "raw_verdict.json": "{}",
     "final_verdict.json": "{}",
     "intervention.json": "{}",
@@ -176,20 +179,26 @@ def build_manifest(
     scp_available: bool | None = None,
     root: Path | None = None,
     started_at: str | None = None,
+    domain: str = "education",
 ) -> dict[str, Any]:
-    """Phase 13 run manifest with every contract field."""
+    """Phase 13 run manifest with every contract field.
+
+    ``domain`` selects which registered frame contract this run must satisfy;
+    it defaults to education so existing callers and manifests stay valid.
+    """
     return {
         "run_id": run_id,
         "skill_version": SKILL_VERSION,
         "git_commit": git_commit(root),
         "started_at": started_at or utc_now(),
         "question": question,
+        "domain": domain,
         "execution_mode": execution_mode,
         "scp_available": detect_scp() if scp_available is None else scp_available,
         "agent_mcp_available": agent_mcp_available,
         "agent_mcp_approved": agent_mcp_approved,
         "resource_policy_version": RESOURCE_POLICY_VERSION,
-        "confidence_policy_version": "2026-08-12.v2",
+        "confidence_policy_version": CONFIDENCE_POLICY_VERSION,
     }
 
 
@@ -249,7 +258,14 @@ class RunWorkspace:
 
     def load_state(self) -> dict[str, Any]:
         state = load_json(self.state_path)
+        # Read old workspaces without treating a presentation record as a
+        # scientific stage. New writes only use the canonical projection name.
+        legacy = (state.get("stages") or {}).pop("present", None)
+        if legacy and "projection" not in state.get("stages", {}):
+            state.setdefault("stages", {})["projection"] = legacy
         state.setdefault("stages", {s: {"status": "pending"} for s in STAGES})
+        for stage in STAGES:
+            state["stages"].setdefault(stage, {"status": "pending"})
         return state
 
     def save_state(self, updates: dict[str, Any] | None = None) -> dict[str, Any]:

package/scripts/search_provenance.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Execute an audited, bounded search plan and persist provenance.
+
+For every explicit query (core / expansion / counter_evidence) this records
+each provider attempt, then exports search-provenance.json,
+search-attempts.jsonl, source-screening.csv and exclusion-log.csv into the
+output directory. A search result without this provenance file is a candidate,
+never evidence.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+for _p in (str(ROOT), str(ROOT / "scripts")):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from retrieval.audit import AuditedSearchExecutor, SearchPlan  # noqa: E402
+from retrieval.search import search_router  # noqa: E402
+
+
+CHANNELS = {
+    "academic": lambda router: router.zero_config_academic,
+    "web": lambda router: router.zero_config_web + router.configured_providers,
+    "all": lambda router: (router.zero_config_academic + router.zero_config_web
+                            + [p for p in router.configured_providers if p.is_available()]),
+}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="audited external search with provenance")
+    parser.add_argument("question", help="research question")
+    parser.add_argument("--out", required=True, type=Path, help="provenance output directory")
+    parser.add_argument("--domain", default="education", choices=["education", "policy"])
+    parser.add_argument("--concept", action="append", default=[], help="concept term (repeatable)")
+    parser.add_argument("--synonym", action="append", default=[], help="synonym term (repeatable)")
+    parser.add_argument("--limit", type=int, default=10)
+    parser.add_argument("--channel", default="all", choices=list(CHANNELS))
+    parser.add_argument("--policy", default="2026.09", help="search policy version")
+    args = parser.parse_args(argv)
+    plan = SearchPlan.from_question(args.question, domain=args.domain,
+                                    concepts=args.concept, synonyms=args.synonym)
+    plan = SearchPlan(plan.question, plan.domain, plan.concepts, plan.synonyms,
+                      plan.inclusion_criteria, plan.exclusion_criteria, plan.queries,
+                      provider_budget=args.limit, policy_version=args.policy)
+    providers = CHANNELS[args.channel](search_router)
+    hits = AuditedSearchExecutor(providers).execute(plan, args.out, limit=args.limit)
+    print(json.dumps({
+        "output": str(args.out),
+        "sources": len(hits),
+        "query_count": len(plan.queries),
+        "counter_evidence_queries": sum(q.purpose == "counter_evidence" for q in plan.queries),
+        "provenance_files": ["search-provenance.json", "search-attempts.jsonl",
+                             "source-screening.csv", "exclusion-log.csv"],
+    }, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/serve_web.py

@@ -1,15 +1,14 @@
 #!/usr/bin/env python3
-"""scripts/serve_web.py — EduEvidence 落地页/静态资源预览服务器（CORS 开启）。
+"""scripts/serve_web.py — EduEvidence 介绍页/静态资源预览服务器（CORS 开启）。
 
-web/ 的营销落地页（landing.html 等）按架构是独立入口，不挂在
-dashboard_server 路由下（P3 gate: /landing.html 必须 404）。本脚本以只读方式
-静态托管 web/，并为所有响应加上 Access-Control-Allow-Origin: *，
-使落地页与不同端口的 Web Studio 控制台之间能做跨源探测与互相跳转。
+`web/landing.html` 是独立的公开介绍页；正式研究控制台由
+`scripts/dashboard_server.py` 提供 `web/studio/` 中的 Research Studio。
+本脚本只用于只读预览介绍页和静态展示资源，不承载研究状态或控制台 API。
 
     python3 scripts/serve_web.py --host 127.0.0.1 --port 8877
 
-首页入口：http://127.0.0.1:8877/landing.html
-控制台：  http://127.0.0.1:8766/（scripts/dashboard_server.py）
+介绍页：http://127.0.0.1:8877/landing.html
+Research Studio：http://127.0.0.1:8765/studio/
 """
 from __future__ import annotations
 
@@ -40,9 +39,9 @@ def main() -> None:
     server = http.server.ThreadingHTTPServer(
         (args.host, args.port), CORSStaticHandler)
     print("=" * 60)
-    print(f"🌐 EduEvidence 落地页 (CORS) running at http://{args.host}:{args.port}/")
-    print(f"   首页      /landing.html")
-    print(f"   控制台   http://{args.host}:8766/  (scripts/dashboard_server.py)")
+    print(f"🌐 EduEvidence 介绍页预览 running at http://{args.host}:{args.port}/")
+    print("   介绍页        /landing.html")
+    print(f"   Research Studio http://{args.host}:8765/studio/  (scripts/dashboard_server.py)")
     print("=" * 60)
     try:
         server.serve_forever()

package/scripts/skill_lint.py

@@ -102,7 +102,7 @@ def lint_skill() -> list[str]:
     # 7. task-briefs 模板（编排链补全）
     brief_dir = ROOT / "skill" / "task-briefs"
     stage_briefs = ["frame", "retrieve", "extract", "challenge", "audit",
-                    "adjudicate", "intervene", "evaluate", "present"]
+                    "adjudicate", "applicability", "intervene", "evaluate", "projection"]
     if not brief_dir.exists():
         errors.append("skill/task-briefs/ is missing (orchestration chain)")
     else: