simcon-toolkit 0.1.0__py3-none-any.whl

simcon_toolkit/_kit/templates/process-window/process_window/emit.py

@@ -0,0 +1,591 @@
+"""G5: emit `doe_spec.yaml` and `dossier.md`.
+
+Assembles every stage's output into the two deliverables, and **runs the guardrail lint before
+writing anything** — if a criterion thresholds an absolute pressure, or the noise floor was
+imported rather than derived, or an absolute-valued claim carries no caveats, this fails and emits
+nothing. A spec that violates the guardrails is worse than no spec.
+
+The dossier records every decision, threshold, run id, rejection and caveat with timestamps, and
+attaches the stated limitations automatically to any claim that rests on absolute values.
+
+Run:  python main.py emit configs/simple-plate.yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from datetime import UTC, datetime
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+from .guardrails import GuardrailViolation, lint_spec
+from .run_screening import GATE_KPI, VARS, load_records
+from .setup_campaign import dossier_dir_for, load_config, resolve_config, runs_dir_for, stage_dir_for
+
+ROOT = Path(__file__).resolve().parents[1]
+
+CAVEATS = {
+    "cavities_1_of_32": (
+        "1 of 32 cavities modelled, fed by a single gate. Verified from the geometry: the part is one connected body of 0.4444 cm3 and one gate was submitted to every run, so every result is per-cavity."
+    ),
+    "no_runner_system": (
+        "No runner system of any kind is in the AI model, so the real tool's hot "
+        "runner is absent rather than approximated. Cavity pressures therefore "
+        "exclude every pressure drop upstream of the gate, the hot runner "
+        "contributes no heat, and cavity-to-cavity balance is not represented at "
+        "all -- with one cavity modelled there is not even a notion of it."
+    ),
+    "no_process_description": "Almost no description of the real process beyond the material.",
+    "material_placeholder": (
+        "Material is PP Generic as a PLACEHOLDER; the real grade was not "
+        "supplied. The wide box, the no-flow gate and the pack/cool nominals "
+        "all derive from the material card, so all three move with it."
+    ),
+    "multi_gate_pressure_underprediction": (
+        "The AI solver was measured to under-predict absolute cavity pressure on MULTI-GATE parts "
+        "(~0.3x on an 8-gate part). This model is single-gate, so that measured factor does not "
+        "apply to it directly and no bias figure is established for the single-gate case. The real "
+        "tool, however, is a 32-cavity hot-runner-fed system -- squarely the regime where the bias "
+        "was found -- so absolute pressures must not be trusted on transfer and the direction of "
+        "the discrepancy is unknown. Hence every criterion is a rank, ratio or comparison."
+    ),
+    "weld_temp_circularity": (
+        "Weld-front temperature was reported to order points well (Spearman ~0.95, roughly constant "
+        "offset) but was tested against a melt perturbation, while melt drives that KPI ~1:1 — "
+        "measured here at an effect share of 0.97, so the correlation is substantially "
+        "self-fulfilling."
+    ),
+    "fill_race_not_transferable": (
+        "Fill-race metrics were measured not to transfer (Spearman 0.10-0.23). Computed here as a "
+        "labelled anomaly detector only, never as a screening criterion."
+    ),
+    "ai_always_fills": (
+        "The AI model fills completely on every run, so 'complete fill / short shot' cannot be the "
+        "binary feasibility gate the brief specifies. Every feasibility statement here is an "
+        "inferred thermal proxy."
+    ),
+    "fake_real_is_not_physics": (
+        "The self-diagnosis ran against fake-real data generated by hidden input deviations on the "
+        "AI solver, so it measures sensitivity to input misspecification, not the AI-to-physics "
+        "offset."
+    ),
+}
+
+
+def git_commit() -> str:
+    try:
+        return (
+            subprocess.run(
+                ["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, text=True, timeout=10
+            ).stdout.strip()
+            or "unknown"
+        )
+    except Exception:
+        return "unknown"
+
+
+def load(p: Path):
+    return json.loads(p.read_text()) if p.exists() else None
+
+
+def build_spec(cfg: dict, stage_dir: Path, runs_dir: Path) -> tuple[dict, dict]:
+    floor = load(stage_dir / "noise_floor.json")
+    scr = load(stage_dir / "g2_screening.json")
+    ref = load(stage_dir / "g3_refinement.json")
+    con = load(stage_dir / "g4_confirmation.json")
+    fb = load(stage_dir / "g6_feedback.json")
+    sweep = load(stage_dir / "g1_sweep.json")
+    if not (floor and scr and ref):
+        missing = [n for n, x in (("noise_floor", floor), ("g2_screening", scr), ("g3_refinement", ref)) if not x]
+        raise SystemExit(f"  missing stage outputs: {', '.join(missing)}")
+
+    recs = load_records(runs_dir, "G1_wide_sweep")
+    ref_recs = load_records(runs_dir, "G3_refinement")
+    eps_recs = load_records(runs_dir, "G1a_epsilon_floor")
+
+    is_ph = bool(cfg["material"].get("is_placeholder"))
+    caveat_keys = [
+        "cavities_1_of_32",
+        "no_runner_system",
+        "no_process_description",
+        "multi_gate_pressure_underprediction",
+        "weld_temp_circularity",
+        "fill_race_not_transferable",
+        "ai_always_fills",
+    ]
+    if is_ph:
+        caveat_keys.insert(0, "material_placeholder")
+    if fb:
+        caveat_keys.append("fake_real_is_not_physics")
+
+    centre = ref["centre"]
+    rbox = ref["recommended_box"]
+    margins = ref["margin_variable_space"]
+    per_kpi = scr["per_kpi"]
+
+    def rank_of(v):
+        spans = {k: per_kpi[k]["effect_span"][v] for k in per_kpi if "effect_span" in per_kpi[k]}
+        return spans
+
+    factors, fixed = [], []
+    for v in VARS:
+        inert_all = scr["inert_across_all_kpis"].get(v, False)
+        gate_span = per_kpi.get(GATE_KPI, {}).get("effect_span", {}).get(v)
+        entry = {
+            "name": v,
+            "unit_engineer": "degC" if v.endswith("_C") else "cm3_s",
+            "centre": round(float(centre[v]), 4),
+            "low": round(float(rbox[v][0]), 4),
+            "high": round(float(rbox[v][1]), 4),
+            "bounds_basis": "derived",
+            "margin_applied": round(float(margins[v]), 4),
+            "effect_share_per_kpi": {k: per_kpi[k]["share"][v] for k in per_kpi if "share" in per_kpi[k]},
+            "effect_span_per_kpi": {k: per_kpi[k]["effect_span"][v] for k in per_kpi if "effect_span" in per_kpi[k]},
+            "gate_effect_span": gate_span,
+            "above_noise_floor_for_gate": (
+                None if gate_span is None else bool(gate_span >= floor["per_kpi"][GATE_KPI]["floor"])
+            ),
+        }
+        if v.endswith("_C"):
+            entry["centre_K"] = round(float(centre[v]) + 273.15, 4)
+            entry["low_K"] = round(float(rbox[v][0]) + 273.15, 4)
+            entry["high_K"] = round(float(rbox[v][1]) + 273.15, 4)
+        if inert_all or (rbox[v][1] - rbox[v][0]) <= 0:
+            entry["role"] = "inert"
+            fixed.append(
+                {
+                    "name": v,
+                    "value": entry["centre"],
+                    "reason": "inert" if inert_all else "no usable window",
+                    "detail": ("effect below the derived floor for every KPI — fixed, not ranked low (guardrail 2)")
+                    if inert_all
+                    else "the safety margin consumed the available room",
+                }
+            )
+        else:
+            entry["role"] = "control"
+            factors.append(entry)
+
+    factors.sort(key=lambda e: -(e.get("gate_effect_span") or 0.0))
+    for i, e in enumerate(factors, 1):
+        e["rank"] = i
+
+    spec = {
+        "schema": "simcon.doe_spec/1",
+        "generated_at": datetime.now(UTC).isoformat(),
+        "generated_by": f"frontloaded-doe POC, commit {git_commit()}",
+        "status": "draft",
+        "part": cfg["part"]["name"],
+        "centre_point": {
+            "definition": "chebyshev_centre_shrunk",
+            "note": (
+                "Deepest interior point of the green region. NOT the survivor mean, which on a "
+                "non-convex or disconnected region can fall outside the region entirely."
+            ),
+            **{
+                v: {
+                    "value": round(float(centre[v]), 4),
+                    **({"value_K": round(float(centre[v]) + 273.15, 4)} if v.endswith("_C") else {}),
+                    "basis": "derived",
+                }
+                for v in VARS
+            },
+            "inradius_normalised": ref["inradius_unit"],
+            "safety_margin": {v: round(float(margins[v]), 4) for v in VARS},
+            "margin_basis": ref.get("band_basis"),
+            "binding_constraint": ref.get("binding_constraint"),
+            "slack_at_centre_bands": ref.get("slack_at_centre_bands"),
+        },
+        "factors": factors,
+        "fixed_factors": fixed
+        + [
+            {
+                "name": "htc_W_m2K",
+                "value": cfg["solver"]["htc_W_m2K"],
+                "reason": "out_of_scope",
+                "detail": "melt-to-mould contact property, not a machine setting; user directive",
+            },
+            {
+                "name": "gate_positions_mm",
+                "value": [list(map(float, g)) for g in load(runs_dir / "campaign_state.json")["gates_mm"]],
+                "reason": "tool_property",
+                "detail": "gate layout is tool design, not a machine parameter; fixed across the DOE",
+            },
+        ],
+        "readouts": [
+            {
+                "name": "switchover_point",
+                "unit": "phi",
+                "values": cfg["variables"]["switchover_readout_phi"],
+                "method": (
+                    "field state read at fill fraction phi from runs already paid for; this is "
+                    "the state AT switchover, not the effect OF switching there"
+                ),
+                "caveats": [
+                    "incompressible melt: the phi axis equates injected with filled volume, "
+                    "sub-percent during fill but worst as phi -> 1, which is where switchover "
+                    "lives"
+                ],
+            }
+        ],
+        "acceptance_criteria": scr["acceptance_criteria"],
+        "noise_floor": {
+            "method": floor["method"],
+            "mechanism": floor["mechanism"],
+            "perturbations": floor["perturbations"],
+            "justification": floor["justification"],
+            "per_kpi": floor["per_kpi"],
+            "applied_relatively": (
+                "the quantisation is floating-point, so the absolute floor "
+                "scales with the KPI value; the inert test uses the relative floor"
+            ),
+        },
+        "feasibility": scr["feasibility"],
+        "feasibility_gate": {
+            "primary": GATE_KPI,
+            "why": (
+                "A short shot is what happens when the flow channel closes. The at-arrival "
+                "reading of the same KPI was measured NOT to discriminate on this part "
+                "(32.9-108.8 K against a 15 K gate) because fountain flow keeps the front hot."
+            ),
+            "fill_completeness": scr.get("fill_completeness_diagnostic"),
+        },
+        "numerical_confirmation": (
+            {
+                "solver": "cadmould_numerical",
+                "mesh": "same_as_ai_runs",
+                "n_points": con["validation_summary"]["decks"],
+                "validated_by_round_trip": con["validation_summary"]["round_trip_ok"],
+                "with_packing": con["validation_summary"]["with_packing"],
+                "pack_nominal": con["pack_nominal"],
+                "cooling_nominal_s": con["cooling_nominal_s"],
+                "switchover_variants": con["switchover_variants"],
+                "rule": con["inward_only_rule"],
+                "status": "prepared, not submitted (scope: decks are the deliverable)",
+                "points": [
+                    {
+                        "id": p["id"],
+                        "role": p["role"],
+                        "melt_C": p["melt_C"],
+                        "wall_C": p["wall_C"],
+                        "flow_cm3_s": p["flow_cm3_s"],
+                        "phi_s": p["phi_s"],
+                        "hold_bar": p["hold_bar"],
+                        "hold_s": p["hold_s"],
+                        "cool_s": p["cool_s"],
+                        "rm1": p["rm1"],
+                        "validated": p["validation"].get("all_ok"),
+                        "note": p["note"],
+                    }
+                    for p in con["points"]
+                ],
+            }
+            if con
+            else {"status": "not built"}
+        ),
+        "provenance": {
+            "part_geometry": {
+                "stl": cfg["part"]["stl"],
+                "cfex": (load(runs_dir / "campaign_state.json") or {}).get("cfex_name"),
+                "volume_cm3": (load(runs_dir / "campaign_state.json") or {}).get("volume_cm3"),
+                "geometry_id": (load(runs_dir / "campaign_state.json") or {}).get("geometry_id"),
+            },
+            "material": {
+                "plb": cfg["material"]["plb"],
+                "catalogue_name": cfg["material"]["catalogue_name"],
+                "is_placeholder": is_ph,
+            },
+            "machine_limits": {
+                **cfg["machine_limits"],
+                "absolute": True,
+                "caveats": ["cavities_1_of_32", "no_runner_system", "multi_gate_pressure_underprediction"],
+            },
+            "wide_box": {
+                v: {
+                    "low": round(float(np.array(sweep["box"][v], float)[0]), 4),
+                    "high": round(float(np.array(sweep["box"][v], float)[1]), 4),
+                    "basis": sweep["box_basis"][v],
+                }
+                for v in VARS
+            }
+            if sweep
+            else None,
+            "ai_runs": {
+                # The provenance that matters is which endpoint answered, not a name for it.
+                "base_url": cfg["cloud"]["rest_base_url"],
+                "model_version": cfg["cloud"]["model_version"],
+                "num_timesteps": cfg["solver"]["num_timesteps"],
+                "stages": {
+                    "G1a_epsilon_floor": len(eps_recs),
+                    "G1_wide_sweep": len(recs),
+                    "G3_refinement": len(ref_recs),
+                },
+                "total_scored": len(eps_recs) + len(recs) + len(ref_recs),
+                "determinism_note": (
+                    "identical request returns an identical result; no replicates "
+                    "were run because they carry zero information"
+                ),
+                "storage_note": (
+                    "raw results scored then discarded (~29 MB each); the solver is "
+                    "deterministic so targeted re-runs are free"
+                ),
+            },
+            "surrogate": ref.get("surrogates"),
+        },
+        "self_diagnosis": (
+            fb.get("self_diagnosis") | {"limitation": fb["limitation"], "source": fb["fake_real_source"]}
+            if fb
+            else {"status": "not run"}
+        ),
+        "guardrail_report": {},
+        "caveats": {k: CAVEATS[k] for k in caveat_keys},
+    }
+    return spec, {
+        "scr": scr,
+        "ref": ref,
+        "con": con,
+        "fb": fb,
+        "floor": floor,
+        "sweep": sweep,
+        "n_sweep": len(recs),
+        "n_ref": len(ref_recs),
+        "n_eps": len(eps_recs),
+        "recs": recs,
+    }
+
+
+def write_dossier(spec: dict, ctx: dict, out: Path, cfg: dict) -> None:
+    scr, ref, con, fb = ctx["scr"], ctx["ref"], ctx["con"], ctx["fb"]
+    L: list[str] = []
+    A = L.append
+    A(f"# DOE dossier — {spec['part']}")
+    A("")
+    A(f"Generated {spec['generated_at']} by {spec['generated_by']}.")
+    A(f"Status: **{spec['status']}**. Model `{cfg['cloud']['model_version']}` at `{cfg['cloud']['rest_base_url']}`.")
+    A("")
+    A(
+        "Beside this file: `doe_spec.yaml`, the machine-readable answer. The stage records it "
+        "was built from are under `cache/`, which is safe to delete."
+    )
+    A("")
+
+    A("## The answer")
+    A("")
+    A("| variable | low | centre | high | margin applied | rank |")
+    A("|---|---|---|---|---|---|")
+    for f in spec["factors"]:
+        A(f"| {f['name']} | {f['low']} | {f['centre']} | {f['high']} | {f['margin_applied']} | {f['rank']} |")
+    for f in spec["fixed_factors"]:
+        A(f"| {f['name']} *(fixed: {f['reason']})* | — | {f.get('value')} | — | — | — |")
+    A("")
+    cp = spec["centre_point"]
+    A(f"Centre point is the **{cp['definition']}** — {cp['note']}")
+    A("")
+    A(
+        f"Binding constraint at the centre: **{cp['binding_constraint']}**. "
+        f"Slack in units of each KPI's own resolution band: `{cp['slack_at_centre_bands']}`."
+    )
+    A("")
+    for n in ref.get("notes", []):
+        A(f"- {n}")
+    A("")
+
+    A("## What was excluded, and why")
+    A("")
+    fe = scr["feasibility"]
+    A(f"- **RED — freeze-off** (`{GATE_KPI}` < {fe['cuts']['no_flow_end_min_K']} K): {fe['red_freeze_off']} points")
+    A(f"- **AMBER — hotspot** worst decile (> {fe['cuts']['hotspot_cut']}): {fe['amber_hotspot']}")
+    A(
+        f"- **AMBER — pressure rank** worst decile (> {fe['cuts']['p80_cut_bar']} bar, "
+        f"ordering only): {fe['amber_pressure_rank']}"
+    )
+    A(f"- **GREEN**: {fe['green']} points ({100 * fe['green_fraction']:.1f}%)")
+    A("")
+    A(
+        f"Gate KPI observed over the sweep: {fe.get('gate_observed_K')} K. "
+        f"At-arrival secondary reading: {fe.get('at_arrival_observed_K')} K."
+    )
+    A("")
+
+    A("## Variable ranking and inert variables")
+    A("")
+    A("| KPI | LOO nrmse | floor applied | " + " | ".join(VARS) + " |")
+    A("|---|---|---|" + "---|" * len(VARS))
+    for k, d in scr["per_kpi"].items():
+        spans = " | ".join(f"{d['effect_span'][v]:.4g}{' **INERT**' if d['inert'][v] else ''}" for v in VARS)
+        A(f"| {k} | {100 * d['loo']['nrmse_range']:.2f}% | {d['floor_applied_here']:.4g} | {spans} |")
+    A("")
+    A(
+        "Effect spans are in each KPI's own units. A variable is declared **inert** — and fixed, not "
+        "ranked low — when its whole-box span falls below that KPI's derived resolution floor."
+    )
+    A("")
+
+    A("## Noise floor (derived for this part, never imported)")
+    A("")
+    nf = spec["noise_floor"]
+    A(f"{nf['mechanism']}")
+    A("")
+    A(f"Perturbations: `{nf['perturbations']}`. {nf['justification']}")
+    A("")
+    A("| KPI | floor | unit | relative | n |")
+    A("|---|---|---|---|---|")
+    for k, d in nf["per_kpi"].items():
+        if d.get("floor") is None:
+            continue
+        A(
+            f"| {k} | {d['floor']:.6g} | {d['unit']} | "
+            f"{d['rel_floor_pct'] if d['rel_floor_pct'] is not None else '—'} | {d['n_runs']} |"
+        )
+    A("")
+    A(f"**{nf['applied_relatively']}**")
+    A("")
+
+    A("## Acceptance criteria")
+    A("")
+    for c in spec["acceptance_criteria"]:
+        A(f"### `{c['name']}` — {c.get('role', '')}")
+        A("")
+        A(f"- expression: `{c['expression']}` (kind: {c['kind']}, absolute: {c['absolute']})")
+        A(f"- reasoning: {c['reasoning']}")
+        for extra in (
+            "why_kelvin_is_allowed",
+            "why_not_the_ratio",
+            "why_the_5th_percentile_not_the_minimum",
+            "why_this_replaced_the_at_arrival_reading",
+        ):
+            if c.get(extra):
+                A(f"- {extra.replace('_', ' ')}: {c[extra]}")
+        if c.get("judgement"):
+            A(f"- **this is a judgement call.** What would change my mind: {c.get('would_change_my_mind')}")
+        A("")
+
+    A("## Numerical confirmation set")
+    A("")
+    if con:
+        nc = spec["numerical_confirmation"]
+        A(
+            f"{nc['n_points']} decks, {nc['validated_by_round_trip']} validated by "
+            f"`Rm1Writer` → `Rm1Reader` round trip, {nc['with_packing']} carrying the packing "
+            f"profile. Built on the **same mesh** as the AI runs. Status: {nc['status']}."
+        )
+        A("")
+        A(
+            f"Packing nominal from `tools.suggest_pack_profile` (peak "
+            f"{nc['pack_nominal']['peak_bar']:.0f} bar, {nc['pack_nominal']['total_s']:.2f} s); "
+            f"cooling {nc['cooling_nominal_s']['value']:.2f} s from `tools.suggest_cooling_time`. "
+            f"Switchover swept at {nc['switchover_variants']}."
+        )
+        A("")
+        A(f"**{nc['rule']}**")
+        A("")
+        A("| id | role | melt °C | wall °C | Q cm³/s | φ_s | validated | note |")
+        A("|---|---|---|---|---|---|---|---|")
+        for p in nc["points"]:
+            A(
+                f"| {p['id']} | {p['role']} | {p['melt_C']} | {p['wall_C']} | {p['flow_cm3_s']} | "
+                f"{p['phi_s']} | {'yes' if p['validated'] else 'NO'} | {p['note']} |"
+            )
+    else:
+        A("Not built.")
+    A("")
+
+    A("## Self-diagnosis")
+    A("")
+    if fb:
+        sd = spec["self_diagnosis"]
+        A(f"**Verdict: {sd['verdict'].upper()}** ({sd['basis']}).")
+        A("")
+        A(f"Thresholds: {sd['thresholds']}. Basis: {sd['threshold_basis']}.")
+        A("")
+        A(f"**Limitation:** {sd['limitation']}")
+        A("")
+        A("| deviation | KPI | mean offset | spread | in floors | verdict | ordering |")
+        A("|---|---|---|---|---|---|---|")
+        for dev, blk in fb["per_deviation"].items():
+            for k, d in blk["per_kpi"].items():
+                if "error" in d:
+                    continue
+                A(
+                    f"| {dev} | {k} | {d['mean_offset']:+.3f} | {d['spread']:.3f} | "
+                    f"{d['spread_in_floors']:.2f} | {d['verdict']} | "
+                    f"{d['ordering']['agreement']} |"
+                )
+    else:
+        A("Not run.")
+    A("")
+
+    A("## Provenance")
+    A("")
+    pr = spec["provenance"]
+    ar = pr["ai_runs"]
+    A(f"- AI runs scored: **{ar['total_scored']}** — {ar['stages']}")
+    A(f"- {ar['determinism_note']}")
+    A(f"- {ar['storage_note']}")
+    A(
+        f"- material: `{pr['material']['catalogue_name']}`"
+        + (" — **PLACEHOLDER**" if pr["material"]["is_placeholder"] else "")
+    )
+    A(f"- machine limits: {cfg['machine_limits']} — applied as annotation only, never as a screening criterion")
+    A("")
+
+    A("## Guardrail report")
+    A("")
+    for c in spec["guardrail_report"].get("checks_passed", []):
+        A(f"- PASS — {c}")
+    A("")
+
+    A("## Stated limitations (attached automatically to absolute-valued claims)")
+    A("")
+    for k, v in spec["caveats"].items():
+        A(f"- **{k}** — {v}")
+    A("")
+
+    out.write_text("\n".join(L), encoding="utf-8")
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G5 emit doe_spec.yaml + dossier.md")
+    ap.add_argument(
+        "config",
+        nargs="?",
+        help="campaign config; defaults to configs/simple-plate.yaml while that is unambiguous",
+    )
+    args = ap.parse_args()
+
+    cfg = load_config(resolve_config(args.config))
+    d = dossier_dir_for(cfg)
+    runs_dir = runs_dir_for(cfg)
+    spec, ctx = build_spec(cfg, stage_dir_for(cfg), runs_dir)
+
+    # Guardrails BEFORE writing. A spec that violates them must not exist.
+    try:
+        passed = lint_spec(spec)
+    except GuardrailViolation as exc:
+        print(f"  GUARDRAIL VIOLATION — nothing emitted:\n    {exc}")
+        return 1
+    spec["guardrail_report"] = {"checks_passed": passed}
+    print(f"  guardrail lint passed ({len(passed)} checks):")
+    for p in passed:
+        print(f"    - {p}")
+
+    yml = d / "doe_spec.yaml"
+    yml.write_text(yaml.safe_dump(spec, sort_keys=False, allow_unicode=True, width=100), encoding="utf-8")
+    print(f"\n  wrote {yml.relative_to(ROOT)}")
+
+    md = d / "dossier.md"
+    write_dossier(spec, ctx, md, cfg)
+    print(f"  wrote {md.relative_to(ROOT)}")
+
+    print("\n  centre: " + ", ".join(f"{v}={spec['centre_point'][v]['value']}" for v in VARS))
+    print("  box:    " + ", ".join(f"{f['name']} {f['low']}..{f['high']}" for f in spec["factors"]))
+    print(f"  AI runs scored: {spec['provenance']['ai_runs']['total_scored']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())