eduevidence 6.0.0 → 6.3.0

package/scripts/check_versioned_schemas.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""check_versioned_schemas.py - data-level validation for v3 / v4 / vNext.
+
+CI validated this contract family by parsing the JSON only, so a schema could
+drift arbitrarily (renamed required fields, changed enums, wrong types) and
+stay green. Each family is exercised here by building a record from its own
+dataclass or builder and validating that record against its schema, which is
+the check that would have caught a real mismatch.
+
+Stdlib only; exit 1 on any invalid record.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / 'scripts'))
+
+
+def _validate(record, schema_rel, label):
+    from validate_schema import SchemaError, Validator
+
+    path = ROOT / schema_rel
+    schema = json.loads(path.read_text(encoding='utf-8'))
+    validator = Validator(schema, base_dir=path.parent)
+    try:
+        validator.validate(record, schema, label)
+    except SchemaError as exc:
+        return f'{label}: {exc}'
+    return None
+
+
+def main() -> int:
+    problems = []
+    checked = 0
+
+    # --- vNext: records built from their own dataclasses -------------------
+    try:
+        from engine.autoresearch.contracts import NegativeSearchRecord
+
+        record = NegativeSearchRecord(
+            negative_search_id='NSR-1', research_iteration_id='RI-1',
+            gap_id='GAP-1', queries=('a', 'b'), providers=('openalex',),
+            candidate_count=0, fetched_count=0, eligible_count=0)
+        payload = record.__dict__ if hasattr(record, '__dict__') else record
+        # JSON round-trip puts tuples back into their serialized form, which is
+        # what actually gets persisted; validate that shape.
+        payload = json.loads(json.dumps(payload, default=str))
+        err = _validate(payload, 'schemas/vNext/negative-search-record.schema.json',
+                        'negative-search-record')
+        if err:
+            problems.append(err)
+        checked += 1
+    except Exception as exc:  # import or construction failure is itself a defect
+        problems.append(f'negative-search-record: could not build record: {exc}')
+
+    # --- vNext: autoresearch lifecycle records ---------------------------
+    # Every schema in this family is exercised against the dataclass that
+    # actually produces it, so a renamed field, retyped value or narrowed
+    # enum fails CI instead of drifting silently. Only `negative-search-record`
+    # was wired before; the rest parsed as JSON and nothing more.
+    try:
+        import dataclasses
+
+        from engine.autoresearch.contracts import (ResearchBudget,
+                                                   ResearchExperimentType,
+                                                   ResearchIteration,
+                                                   ResearchStrategy,
+                                                   IterationStatus)
+        from engine.autoresearch.gap_priority import GapPriority
+
+        strategy = ResearchStrategy(
+            strategy_id='RST-1',
+            experiment_type=ResearchExperimentType.TARGETED_RETRIEVAL,
+            hypothesis='a targeted retrieval closes the retention gap',
+            expected_gain='one or more direct retention findings',
+            budget=ResearchBudget())
+        iteration = ResearchIteration(
+            iteration_id='RI-1', project_id='PRJ-1', base_graph_revision=1,
+            gap_id='GAP-1', strategy=strategy)
+        iteration.complete(IterationStatus.SEARCH_SATURATED)
+        iteration_payload = json.loads(json.dumps(iteration.as_dict(), default=str))
+        strategy_payload = json.loads(json.dumps(dataclasses.asdict(strategy), default=str))
+        strategy_payload['experiment_type'] = strategy.experiment_type.value
+        priority = GapPriority(
+            gap_id='GAP-1', dvi_band='HIGH', cost_band='LOW',
+            decision_material=True, drivers=('missing_retention',),
+            # The enum is the controller's own vocabulary (gap_priority.py and
+            # controller.py emit these three); it is not the experiment-type
+            # vocabulary. Using a plausible-looking but wrong value here is
+            # exactly the drift this check exists to catch.
+            next_research_mode='secondary_evidence_search', score=1)
+        priority_payload = json.loads(json.dumps(dataclasses.asdict(priority), default=str))
+
+        for label, payload, schema_rel in (
+            ('research-strategy', strategy_payload, 'schemas/vNext/research-strategy.schema.json'),
+            ('research-iteration', iteration_payload, 'schemas/vNext/research-iteration.schema.json'),
+            ('gap-priority', priority_payload, 'schemas/vNext/gap-priority.schema.json'),
+        ):
+            err = _validate(payload, schema_rel, label)
+            if err:
+                problems.append(err)
+            checked += 1
+    except Exception as exc:
+        problems.append(f'autoresearch lifecycle records: could not build record: {exc}')
+
+    # --- vNext: orchestration plan and task contracts ---------------------
+    try:
+        import dataclasses as _dc
+
+        from engine.orchestration import ExecutionPlanner, ExecutionMode
+
+        # A delegated plan needs a run id and a base revision; without them
+        # TaskSpec.validate_for_dispatch refuses to describe a dispatchable task.
+        plan = ExecutionPlanner().plan('M', run_id='RUN-1', base_revision=1)
+        plan_payload = json.loads(json.dumps(_dc.asdict(plan), default=str))
+        plan_payload['complexity'] = str(getattr(plan.complexity, 'value', plan.complexity))
+        err = _validate(plan_payload, 'schemas/vNext/execution-plan.schema.json',
+                        'execution-plan')
+        if err:
+            problems.append(err)
+        checked += 1
+
+        delegated = [t for t in plan.tasks if t.execution_mode is ExecutionMode.DELEGATED]
+        if not delegated:
+            problems.append('execution plan has no delegated task to exercise task-spec')
+        else:
+            task_payload = json.loads(json.dumps(delegated[0].to_dict(), default=str))
+            err = _validate(task_payload, 'schemas/vNext/task-spec.schema.json', 'task-spec')
+            if err:
+                problems.append(err)
+            checked += 1
+
+            # A WorkerResult is built only by the lead process, which ignores
+            # worker self-attestation; exercise that real path, not a hand-built dict.
+            from engine.worker_result import validate_worker_output
+            result = validate_worker_output(delegated[0], {
+                'task_id': delegated[0].task_id,
+                'status': 'completed',
+                'staging_artifacts': [{'artifact_type': delegated[0].expected_outputs[0],
+                                       'summary': 'staged'}],
+                'validated': True,
+                'metrics': {},
+                'summary': 'ok',
+            })
+            err = _validate(json.loads(json.dumps(result.to_dict(), default=str)),
+                            'schemas/vNext/worker-result.schema.json', 'worker-result')
+            if err:
+                problems.append(err)
+            checked += 1
+    except Exception as exc:
+        problems.append(f'orchestration records: could not build record: {exc}')
+
+    # --- vNext: autoevolve session and experiment records -----------------
+    try:
+        import dataclasses as _dc2
+
+        from engine.autoevolve.core import EvalSnapshot, SkillExperiment
+
+        snapshot = EvalSnapshot(
+            eval_id='EVAL-1', hard_gates_passed=True, science_score=0.8,
+            research_score=0.7, robustness=0.9, cost=0.0,
+            latency=12.5, complexity=0.5, repeats=3, noise_floor=0.01,
+            dev_passed=True, holdout_passed=True, adversarial_passed=True,
+            holdout_isolation_verified=False, eval_suite_hash='deadbeef')
+        snapshot_payload = json.loads(json.dumps(_dc2.asdict(snapshot), default=str))
+        err = _validate(snapshot_payload, 'schemas/vNext/eval-snapshot.schema.json',
+                        'eval-snapshot')
+        if err:
+            problems.append(err)
+        checked += 1
+
+        experiment = SkillExperiment(
+            experiment_id='EXP-1', session_id='session-1',
+            parent_skill_revision='rev-1', hypothesis='a narrower prompt scores higher',
+            mutation_scope=('safe',), changed_files=('skill/agents/skeptic.md',),
+            candidate_commit='deadbeef', baseline_eval_id='EVAL-1',
+            candidate_eval_id='EVAL-2', protected_hash_before='h1',
+            protected_hash_after='h1', status='REJECT',
+            promotion_reason='no significant improvement')
+        experiment_payload = json.loads(json.dumps(_dc2.asdict(experiment), default=str))
+        err = _validate(experiment_payload, 'schemas/vNext/skill-experiment.schema.json',
+                        'skill-experiment')
+        if err:
+            problems.append(err)
+        checked += 1
+
+        # The session report is the real runner payload (runner.py writes
+        # daily-report.json); validate that documented shape directly.
+        session_report = {
+            'run_tag': 'session-1', 'branch': 'autoevolve/session-1',
+            'experiments': 1, 'statuses': ['REJECT'], 'best_experiment_id': None,
+            'best_candidate_commit': None, 'cost': 0.0, 'wall_minutes': 1.0,
+            'plateau': False, 'stop_reason': 'completed',
+            'promotion': 'branch_only', 'branch_push_requested': False,
+            'branch_pushed': False, 'mutation_view': 'dev_only_context_isolation',
+            'holdout_isolation_verified': False, 'isolation_provider': 'none',
+            'isolation_reason': 'no os isolation provider available',
+            'eval_suite_hash': 'deadbeef', 'security_note': 'branch only',
+            'candidate_artifacts': 'local session state only; never auto-pushed',
+        }
+        err = _validate(session_report, 'schemas/vNext/autoevolve-session.schema.json',
+                        'autoevolve-session')
+        if err:
+            problems.append(err)
+        checked += 1
+    except Exception as exc:
+        problems.append(f'autoevolve records: could not build record: {exc}')
+
+    # --- v3: the BENCHMARK run manifest (scripts/benchmark_v3.py) ---------
+    # Note: schemas/v3/run-manifest.schema.json describes the empirical
+    # benchmark harness record, not the run-workspace manifest. Validating the
+    # wrong producer is how a contract silently stops describing reality.
+    try:
+        fixture = sorted((ROOT / 'benchmarks' / 'empirical').glob('*/manifest.json'))
+        if fixture:
+            payload = json.loads(fixture[0].read_text(encoding='utf-8'))
+            err = _validate(payload, 'schemas/v3/run-manifest.schema.json',
+                            f'run-manifest ({fixture[0].parent.name})')
+            if err:
+                problems.append(err)
+            checked += 1
+        else:
+            # benchmarks/empirical/ holds local empirical runs and is excluded
+            # from the submission package on purpose. Its absence means there is
+            # nothing to check in this checkout, not that the contract is broken.
+            print('note: no benchmarks/empirical/*/manifest.json in this checkout; '
+                  'skipping the v3 run-manifest data check')
+    except Exception as exc:
+        problems.append(f'v3 run-manifest: {exc}')
+
+    # --- sanity: every declared schema still parses -----------------------
+    for family in ('v3', 'v4', 'vNext'):
+        for path in sorted((ROOT / 'schemas' / family).glob('*.json')):
+            try:
+                json.loads(path.read_text(encoding='utf-8'))
+                checked += 1
+            except (OSError, json.JSONDecodeError) as exc:
+                problems.append(f'{path.relative_to(ROOT)}: {exc}')
+
+    if problems:
+        print('ERROR: versioned schema validation failed', file=sys.stderr)
+        for item in problems:
+            print(f'  {item}', file=sys.stderr)
+        return 1
+    print(f'versioned schemas OK ({checked} checks across v3 / v4 / vNext)')
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/scripts/claim_audit.py

@@ -27,14 +27,19 @@ from pathlib import Path
 
 from evidence_semantics import claim_relation
 
-SUPPORTED_OUTCOMES = {
-    "knowledge_gain", "concept_understanding", "retention", "transfer",
-    "independent_problem_solving", "completion_time", "accuracy",
-    "code_quality", "assignment_score", "engagement", "motivation",
-    "cognitive_load", "help_seeking", "metacognition", "ai_dependency",
-    "over_reliance", "reduced_effort", "reduced_transfer",
-    "academic_integrity_risk", "false_confidence",
-}
+def _supported_outcomes() -> set[str]:
+    """Every registered outcome token, read from the domain registry.
+
+    This was a hand-copied 20-token education list in three separate files;
+    it silently rejected policy tokens such as policy_effectiveness. The
+    registry (domains/<id>/outcome_taxonomy.json) is the single authority.
+    """
+    from engine.taxonomy import all_tokens_ordered
+
+    return set(all_tokens_ordered())
+
+
+SUPPORTED_OUTCOMES = _supported_outcomes()
 
 
 def load_records(path: Path) -> list[dict]:

package/scripts/compute_confidence.py

@@ -40,6 +40,16 @@ import json
 import sys
 from pathlib import Path
 
+# This module is also documented as a standalone command (SKILL.md), so it
+# has to find the repository root on its own path; the orchestrator sets
+# sys.path for it, which hid the missing import from that caller.
+import sys as _sys
+from pathlib import Path as _Path
+_ROOT = _Path(__file__).resolve().parent.parent
+if str(_ROOT) not in _sys.path:
+    _sys.path.insert(0, str(_ROOT))
+
+
 from evidence_score import (CONFIDENCE_POLICY_VERSION,
                             decision_consistency_score, directness_score,
                             independent_samples, independent_studies)

package/scripts/dashboard_server.py

@@ -524,7 +524,8 @@ class StudioHandler(http.server.SimpleHTTPRequestHandler):
         self._send_report_bytes(html_path.read_bytes())
 
 
-def run_dashboard_server(host: str = "127.0.0.1", port: int = 8765) -> None:
+def run_dashboard_server(host: str = "127.0.0.1", port: int = 8765,
+                         open_browser: bool = False) -> None:
     server = None
     actual_port = port
     for offset in range(10):
@@ -541,12 +542,20 @@ def run_dashboard_server(host: str = "127.0.0.1", port: int = 8765) -> None:
     if server is None:
         print(f"❌ 端口 {port}-{port + 9} 均被占用。")
         return
+    studio_url = f"http://{host}:{actual_port}/studio/"
     print("============================================================")
     print(f"🚀 EduEvidence Web Studio running at http://{host}:{actual_port}/")
     print("   Research Studio  /studio/  (read-only)")
     print("   Projects, evidence, revisions and five-theme reports")
     print("   Projection API   /api/studio/catalog")
     print("============================================================")
+    if open_browser:
+        try:
+            import webbrowser
+            webbrowser.open(studio_url)
+            print(f"🌐 opened {studio_url}")
+        except Exception as exc:  # pragma: no cover - browser may be absent
+            print(f"⚠️  failed to open browser: {exc}")
     try:
         server.serve_forever()
     except KeyboardInterrupt:
@@ -557,8 +566,10 @@ def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--host", default="127.0.0.1")
     parser.add_argument("--port", type=int, default=8765)
+    parser.add_argument("--open", action="store_true",
+                        help="open the Studio URL in the system browser once the server is up")
     args = parser.parse_args()
-    run_dashboard_server(args.host, args.port)
+    run_dashboard_server(args.host, args.port, open_browser=args.open)
 
 
 if __name__ == "__main__":

package/scripts/did_regression.py

@@ -102,12 +102,22 @@ def run_did_analysis(csv_path: str) -> Dict[str, Any]:
         cl = col.strip().lower()
         if cl in ("cluster_id", "class_id", "school_id", "group_id") or cl.endswith("_cluster"):
             cluster_columns.append(col)
+        # Order matters. An outcome column is often named "post_test_score",
+        # which also contains "post": matching the period rule first stole the
+        # outcome column and the run failed with ERR_MISSING_COLUMNS. Outcome
+        # and treatment are the more specific patterns, so they are tested
+        # before the period keyword.
         if "treat" in cl or cl in ("group", "condition", "is_treatment"):
             field_map["treat"] = col
-        elif "post" in cl or "after" in cl or "period" in cl or "time" in cl or "pre_post" in cl:
+        elif cl in ("post", "posttest", "pre_post", "period", "time_period"):
             field_map["post"] = col
-        elif "score" in cl or "outcome" in cl or "grade" in cl or "result" in cl or "performance" in cl or cl == "y":
+        elif ("score" in cl or "outcome" in cl or "grade" in cl or "result" in cl
+              or "performance" in cl or cl == "y"):
             field_map["outcome"] = col
+        elif "post" in cl or "after" in cl or "period" in cl or "time" in cl:
+            # Generic period/phase column, only after the specific patterns
+            # above have had their chance.
+            field_map.setdefault("post", col)
 
     if "treat" not in field_map or "post" not in field_map or "outcome" not in field_map:
         return {

package/scripts/evidence_score.py

@@ -36,8 +36,11 @@ from evidence_semantics import claim_relation, decision_relation
 DIMENSIONS = ["D1_study_design", "D2_sample_quality", "D3_measurement_validity",
               "D4_temporal_strength", "D5_directness"]
 
-#: Version of the deterministic confidence policy (bump on any formula change).
-CONFIDENCE_POLICY_VERSION = "2026-08-12.v2"
+#: Version of the deterministic confidence policy. Imported from the engine so
+#: there is one authority: evidence_score previously hard-coded ".v2" while
+#: engine/versions.py declared ".v3", so verdicts recorded a policy version the
+#: engine did not recognise and nothing compared the two.
+from engine.versions import CONFIDENCE_POLICY_VERSION  # noqa: F401  (re-export)
 
 
 def quality_score(dimensions: dict[str, int]) -> float:

package/scripts/intake/__init__.py

@@ -0,0 +1,31 @@
+"""intake — one-shot two-round user intake + durable prefs + report open."""
+from __future__ import annotations
+
+from .browser import (
+    maybe_open_after_run,
+    open_report,
+    open_url,
+    resolve_main_report,
+)
+from .constants import (
+    DEPTH_CHOICES,
+    ENHANCEMENTS,
+    ENHANCEMENT_BLURBS,
+    DEPTH_BLURBS,
+    FRAME_SLOTS,
+    THEME_NAMES,
+)
+from .depth import auto_resolve_depth, resolve_depth
+from .background import infer_frame_hints
+from .prefs import default_prefs, load_prefs, prefs_path, save_prefs
+from .prompts import PROMPT_SCRIPT
+from .session import run_intake
+
+__all__ = [
+    "DEPTH_BLURBS", "DEPTH_CHOICES", "ENHANCEMENTS", "ENHANCEMENT_BLURBS",
+    "FRAME_SLOTS", "PROMPT_SCRIPT", "THEME_NAMES",
+    "auto_resolve_depth", "default_prefs", "infer_frame_hints",
+    "load_prefs", "maybe_open_after_run", "open_report", "open_url",
+    "prefs_path", "resolve_depth", "resolve_main_report", "run_intake",
+    "save_prefs",
+]

package/scripts/intake/__main__.py

@@ -0,0 +1,18 @@
+"""python -m intake — CLI entry."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+# Allow `python scripts/intake/__main__.py` without installing the package.
+if __package__ in (None, ""):
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from intake.cli import main  # noqa: E402
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ValueError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        raise SystemExit(2) from exc

package/scripts/intake/background.py

@@ -0,0 +1,78 @@
+"""Frame skeleton inference + 3–6 boundary questions (never fabricate)."""
+from __future__ import annotations
+
+import re
+from typing import Any, Callable
+
+from .constants import (
+    CONTEXT_CUES,
+    FRAME_SLOTS,
+    OUTCOME_CUES,
+    POP_CUES,
+    SLOT_LABELS,
+)
+from .prompts import ask, ask_yes
+
+
+def infer_frame_hints(question: str, domain: str = "education") -> dict[str, Any]:
+    """Propose Frame boundary hints from the question text only.
+
+    Anything not stated in the question stays absent. Never fabricate.
+    """
+    hints: dict[str, Any] = {"domain": domain, "confirmed": False}
+    text = question or ""
+    low = text.lower()
+    for cue in POP_CUES:
+        if cue.lower() in low:
+            hints["population"] = cue
+            break
+    for cue in OUTCOME_CUES:
+        if cue.lower() in low:
+            hints["primary_outcome"] = cue
+            break
+    for cue in CONTEXT_CUES:
+        if cue in text or cue.lower() in low:
+            hints["context"] = cue
+            break
+    m = re.search(r"(AI[\w\s一-鿿]{0,20}(?:工具|助手|tutor|copilot|编程)|"
+                  r"(?:翻转|项目式|同伴)教学|AI\s*编程助手)", text, re.I)
+    if m:
+        hints["intervention"] = m.group(0).strip()
+    if re.search(r"是否|影响|对比|比较|vs|与.*比|是否允许|该不该", text):
+        hints["comparison"] = "business as usual / 未使用该干预的常规做法"
+    return hints
+
+
+def boundary_questions(inferred: dict[str, Any]) -> list[tuple[str, str, str | None]]:
+    """3–6 boundary questions: (slot, prompt, default)."""
+    questions: list[tuple[str, str, str | None]] = []
+    for slot in FRAME_SLOTS:
+        questions.append((slot, f"  · {SLOT_LABELS[slot]}", inferred.get(slot)))
+    return questions[:6]
+
+
+def collect_frame_hints(question: str, *, domain: str = "education",
+                        interactive: bool,
+                        printer: Callable[[str], None] = print) -> dict[str, Any]:
+    """Infer skeleton; when interactive, ask 3–6 boundary Qs + one confirm."""
+    inferred = infer_frame_hints(question, domain=domain)
+    frame_hints = dict(inferred)
+    if not interactive:
+        frame_hints["confirmed"] = False
+        return frame_hints
+
+    printer("—— 背景智能深挖（Frame 边界，智能默认 + 一次确认；缺失不编造）——")
+    printer(f"  领域骨架：{domain}")
+    for slot, prompt, default in boundary_questions(inferred):
+        label = default if default is not None else "（未从题目推出，留空）"
+        raw = ask(prompt, label if default is not None else "")
+        if raw and not raw.startswith("（"):
+            frame_hints[slot] = raw
+        elif default is not None:
+            frame_hints[slot] = default
+        # else: leave absent — never fabricate
+    printer("  Frame 边界摘要：")
+    for slot in FRAME_SLOTS:
+        printer(f"    {slot}: {frame_hints.get(slot) or '—'}")
+    frame_hints["confirmed"] = ask_yes("  确认以上边界？(Y/n)", True)
+    return frame_hints

package/scripts/intake/browser.py

@@ -0,0 +1,79 @@
+"""Main-report resolution and optional system-browser open."""
+from __future__ import annotations
+
+import webbrowser
+from pathlib import Path
+
+from .constants import THEME_NAMES
+from .prefs import load_prefs
+from .prompts import is_interactive
+
+
+def resolve_main_report(directory: Path | str, theme: str | None = None) -> Path | None:
+    """Pick the main report file. All five themes stay on disk.
+
+    Preference order:
+      reports-5themes/EduEvidence_Report_<theme>.html
+      reports-5themes/EduEvidence_Report_claude.html
+      report.html
+      EduEvidence_Report.html
+    """
+    root = Path(directory)
+    if not root.is_dir():
+        return None
+    theme = theme if theme in THEME_NAMES else "claude"
+    variants = root / "reports-5themes"
+    candidates = [
+        variants / f"EduEvidence_Report_{theme}.html",
+        variants / "EduEvidence_Report_claude.html",
+        root / "report.html",
+        root / "EduEvidence_Report.html",
+    ]
+    for path in candidates:
+        if path.is_file() and path.stat().st_size > 2:
+            return path
+    return None
+
+
+def open_report(directory: Path | str, theme: str | None = None,
+                *, force: bool = False) -> bool:
+    """Open the preferred main report in the system browser.
+
+    Only opens when `force` or prefs.open_browser is set. The caller should
+    also suppress this on non-TTY if silent behaviour is required.
+    """
+    prefs = load_prefs()
+    if not force and not prefs.get("open_browser", True):
+        return False
+    path = resolve_main_report(directory, theme or prefs.get("default_main_theme"))
+    if path is None:
+        return False
+    try:
+        webbrowser.open(path.resolve().as_uri())
+    except Exception:
+        return False
+    return True
+
+
+def open_url(url: str, *, force: bool = False) -> bool:
+    prefs = load_prefs()
+    if not force and not prefs.get("open_browser", True):
+        return False
+    try:
+        webbrowser.open(url)
+    except Exception:
+        return False
+    return True
+
+
+def maybe_open_after_run(run_dir: Path | str, *, theme: str | None = None,
+                         interactive: bool | None = None) -> bool:
+    """End-of-run auto-open. Silent on non-TTY so tests stay quiet."""
+    if interactive is None:
+        interactive = is_interactive()
+    if not interactive:
+        return False
+    prefs = load_prefs()
+    if not prefs.get("open_browser", True):
+        return False
+    return open_report(run_dir, theme or prefs.get("default_main_theme"), force=True)

package/scripts/intake/cli.py

@@ -0,0 +1,57 @@
+"""CLI for the one-shot two-round intake."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .constants import DEPTH_CHOICES, ENHANCEMENTS
+from .prefs import load_prefs
+from .prompts import PROMPT_SCRIPT
+from .session import run_intake
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="EduEvidence two-round intake")
+    parser.add_argument("--question", default=None, help="research question")
+    parser.add_argument("--depth", default=None,
+                        choices=list(DEPTH_CHOICES) + ["quick", "standard", "deep"],
+                        help="S/M/L/auto (or legacy quick/standard/deep)")
+    parser.add_argument("--enhancement", action="append", default=None,
+                        choices=list(ENHANCEMENTS),
+                        help="execution enhancement (repeatable)")
+    parser.add_argument("--domain", default="education")
+    parser.add_argument("--yes", action="store_true",
+                        help="skip prompts; use prefs + explicit flags (unattended)")
+    parser.add_argument("--print-prompts", action="store_true",
+                        help="print the fixed two-round prompt script and exit")
+    parser.add_argument("--show-prefs", action="store_true",
+                        help="print current prefs.json and exit")
+    args = parser.parse_args(argv)
+
+    if args.print_prompts:
+        sys.stdout.write(PROMPT_SCRIPT)
+        return 0
+    if args.show_prefs:
+        print(json.dumps(load_prefs(), ensure_ascii=False, indent=2))
+        return 0
+
+    record = run_intake(
+        question=args.question,
+        depth=args.depth,
+        enhancements=args.enhancement,
+        domain=args.domain,
+        assume_yes=args.yes,
+    )
+    print(json.dumps(record, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    # Documented entry: `python3 -m intake.cli --print-prompts` from scripts/.
+    # Same failure contract as scripts/intake/__main__.py.
+    try:
+        raise SystemExit(main())
+    except ValueError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        raise SystemExit(2) from exc