simcon-toolkit 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,370 @@
+"""G2: screen the sweep. Rank the variables, drop the inert ones, map what is red and why.
+
+Reads the per-run records straight from `cache/runs/<part-key>/<stage>/`, so it works on a partial sweep too —
+useful while G1 is still going, and the reason the harness writes one file per run.
+
+The acceptance criteria applied here are *ours to invent and justify* (the brief says so
+explicitly). Each is stated with its physical reasoning and what would change our mind, and each
+is a rank or a dimensionless ratio so the guardrail lint passes.
+
+Run:  python main.py screen [configs/simple-plate.yaml]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import numpy as np
+
+from . import surrogate as S
+from .guardrails import check_criteria
+from .setup_campaign import (
+    load_config,
+    resolve_config,
+    runs_dir_for,
+    stage_dir_for,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+
+VARS = ("melt_C", "wall_C", "flow_cm3_s")
+KPIS = (
+    "p80_bar",
+    "no_flow_margin_end_K",
+    "frozen_fraction_end",
+    "no_flow_margin_K",
+    "no_flow_margin",
+    "weld_front_temp_K",
+    "weld_front_temp_ratio",
+    "hotspot",
+)
+
+# ---------------------------------------------------------------------------
+# Acceptance criteria. Each carries its reasoning and what would change our mind.
+# ---------------------------------------------------------------------------
+GATE_KPI = "no_flow_margin_end_K"
+NO_FLOW_END_MIN_K = 10.0  # superheat above no-flow at end of fill, 5th percentile, in K
+NO_FLOW_MIN_K = 15.0  # at-arrival reading, kept as a reported secondary
+HOTSPOT_WORST_FRACTION = 0.10
+P80_WORST_FRACTION = 0.10
+
+CRITERIA = [
+    {
+        "name": "no_flow_guard_end_of_fill",
+        "kind": "comparison",
+        "kpi": GATE_KPI,
+        "expression": f"no_flow_margin_end_K >= {NO_FLOW_END_MIN_K}",
+        "absolute": False,
+        "role": "hard feasibility gate",
+        "reasoning": (
+            "A short shot is what happens when the flow channel closes before the cavity is full, "
+            "so the causal quantity is whether the melt CHANNEL stays open — not whether the front "
+            "is hot on arrival. This reading is the 5th percentile of core temperature at end of "
+            "fill, minus the no-flow temperature: at 0, a twentieth of the part's core has "
+            "solidified while material still had to pass through it. Requiring 10 K of headroom "
+            "covers what the model does not see: 1 of 32 cavities fed by a single gate, with no "
+            "runner system at all — so every pressure drop upstream of the gate is missing, the "
+            "hot runner contributes no heat, and cavity-to-cavity feed imbalance is not "
+            "represented even in principle. "
+            "For honesty about how much protection that is: the derived floor for this KPI on this "
+            "part is 2.69 K, so 10 K is only 3.7x the resolution limit — thinner cover than the "
+            "at-arrival gate had, and a reason the G4 boundary probes matter."
+        ),
+        "why_the_5th_percentile_not_the_minimum": (
+            "The minimum is dominated by the mesher's degenerate slivers — it reports 0.010 mm as "
+            "the smallest measured thickness — and swings ~90 K on a handful of nodes. Measured on "
+            "the nominal point: minimum -16.6 K while the fraction of nodes actually below no-flow "
+            "is ~0 %. A robust percentile is the same physical quantity without the extremum "
+            "fragility, and it is the same reason `hotspot` uses p95-p05."
+        ),
+        "why_this_replaced_the_at_arrival_reading": (
+            "The at-arrival reading was measured NOT to discriminate on this part: over 250 sweep "
+            "runs it spanned 32.9-108.8 K against a 15 K gate, never approaching it, because "
+            "fountain flow continuously replenishes the front with core melt so the front stays "
+            "near melt temperature (F15). Corner probes then showed this reading swinging from "
+            "+61.6 K at nominal to -7.6 K at the cold/slow corner — it changes sign where the "
+            "at-arrival reading barely moves (F16). Both are 'distance to the material's no-flow "
+            "temperature', so this is a second reading of the approved KPI, not a new one; the "
+            "at-arrival value is still reported."
+        ),
+        "why_kelvin_is_allowed": (
+            "Guardrail 1 forbids absolute *pressure* thresholds for a measured reason: the AI "
+            "solver under-predicts absolute cavity pressure on multi-gate parts (~0.3x on 8 "
+            "gates), so a pressure in bar is a number known to be wrong. No such bias is "
+            "documented for temperature, and F7 measured the field tracking the requested melt to "
+            "within 1 K on this part. The guardrail targets a known multiplicative bias, not units."
+        ),
+        "judgement": True,
+        "would_change_my_mind": (
+            "A measured cavity-to-cavity melt-temperature spread for the real 32-cavity tool would "
+            "set this properly. A numerical confirmation run that fills cleanly at 0 K margin would "
+            "show 10 K is too conservative — G4 probes just outside this edge for that reason."
+        ),
+    },
+    {
+        "name": "no_flow_at_arrival_secondary",
+        "kind": "comparison",
+        "kpi": "no_flow_margin_K",
+        "expression": f"no_flow_margin_K >= {NO_FLOW_MIN_K}",
+        "absolute": False,
+        "role": "reported secondary, NOT a gate",
+        "reasoning": (
+            "Retained because it is the literal reading of the approved KPI and because it answers "
+            "a different question — did the melt arrive still molten. Measured not to discriminate "
+            "on this part (see above), so it informs rather than screens."
+        ),
+        "judgement": False,
+        "would_change_my_mind": "A part where the front genuinely cools before arriving.",
+    },
+    {
+        "name": "hotspot_risk_flag",
+        "kind": "rank",
+        "kpi": "hotspot",
+        "expression": f"hotspot_rank <= {1 - HOTSPOT_WORST_FRACTION}",
+        "absolute": False,
+        "role": "warpage risk flag (amber, not a hard gate)",
+        "reasoning": (
+            "In-plane spread of core temperature at end of fill, normalised by (melt - wall). "
+            "Differential shrinkage drives warpage, and differential shrinkage is driven by "
+            "temperature *differences* across the part at the start of packing — uniformly hot "
+            "is not a warpage risk, unevenly hot is. Used as a rank, not a threshold, because "
+            "the brief forbids predicting warpage: this flags risk, it does not quantify it. "
+            f"Amber on the worst {HOTSPOT_WORST_FRACTION:.0%}. "
+            "Held deliberately weak because this KPI has a 4.45 % resolution floor — an order of "
+            "magnitude worse than the others (F8) — so only coarse distinctions are honest."
+        ),
+        "judgement": True,
+        "would_change_my_mind": (
+            "A numerical pack+cool+warp run on two points of equal p80 but very different "
+            "hotspot. If measured warpage does not separate them, this metric is not earning its "
+            "place and should be dropped rather than reported."
+        ),
+    },
+    {
+        "name": "pressure_ordering",
+        "kind": "rank",
+        "kpi": "p80_bar",
+        "expression": f"p80_rank <= {1 - P80_WORST_FRACTION}",
+        "absolute": False,
+        "role": "preference (amber), never feasibility",
+        "reasoning": (
+            "p80 orders points and nothing more. The AI solver under-predicts absolute cavity "
+            "pressure on multi-gate parts (~0.3x on 8 gates) and the real tool is a 32-cavity "
+            "hot-runner system while we model 1 cavity with no runner, so "
+            "any comparison against a pressure in bar — including the 1500 bar machine limit — "
+            "would be a wrong number against a right one. Rank is preserved under that bias; a "
+            "threshold is not. Amber on the worst decile only."
+        ),
+        "judgement": False,
+        "would_change_my_mind": "Nothing short of a validated absolute-pressure calibration.",
+    },
+]
+
+
+def load_records(runs_dir: Path, stage: str, *, quiet: bool = False) -> list[dict]:
+    """Load scored records for a stage, skipping any from a superseded KPI definition.
+
+    Records produced under an earlier `KPI_VERSION` are kept on disk as history, so the loader has
+    to filter rather than assume. Filtering on the *presence of the required KPIs* rather than only
+    on the version string also covers records written before `kpi_version` was recorded at all.
+    """
+    out, stale = [], 0
+    for p in sorted((runs_dir / stage).glob("*.json")):
+        try:
+            d = json.loads(p.read_text())
+        except (OSError, ValueError):
+            continue
+        k = d.get("kpis")
+        if not k:
+            continue
+        if any(key not in k for key in KPIS):
+            stale += 1
+            continue
+        out.append(d)
+    if stale and not quiet:
+        print(f"    ({stale} record(s) in {stage} skipped: superseded KPI definition)")
+    return out
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G2 screening")
+    ap.add_argument(
+        "config",
+        nargs="?",
+        help="campaign config; defaults to configs/simple-plate.yaml while that is unambiguous",
+    )
+    ap.add_argument("--stage", default="G1_wide_sweep")
+    args = ap.parse_args()
+
+    cfg = load_config(resolve_config(args.config))
+    runs_dir = runs_dir_for(cfg)
+    stage_dir = stage_dir_for(cfg)
+    recs = load_records(runs_dir, args.stage)
+    if len(recs) < 40:
+        print(f"  only {len(recs)} scored runs in {args.stage}; need >=40 for a useful surrogate")
+        return 1
+
+    check_criteria(CRITERIA)  # guardrail lint BEFORE anything is filtered
+    print(f"  guardrail lint passed on {len(CRITERIA)} criteria")
+
+    # The floor is part-specific by construction (guardrail 2), so it is read from this part's
+    # own stages folder. Importing another part's would be exactly the violation the rule names.
+    floor_path = stage_dir / "noise_floor.json"
+    if not floor_path.exists():
+        print(
+            f"  no derived noise floor at {floor_path.relative_to(ROOT)} — "
+            "run `python main.py epsilon-floor` for THIS part first (guardrail 2)."
+        )
+        return 1
+    floor = json.loads(floor_path.read_text())
+    X = np.array([[r["spec"][v] for v in VARS] for r in recs], float)
+    box = np.array([[X[:, i].min(), X[:, i].max()] for i in range(len(VARS))])
+    print(f"\n  {len(recs)} scored runs; observed box:")
+    for i, v in enumerate(VARS):
+        print(f"    {v:12s} {box[i, 0]:8.2f} .. {box[i, 1]:8.2f}")
+
+    # ---- per-KPI surrogate, ranking, inert test --------------------------
+    per_kpi: dict[str, dict] = {}
+    print("\n  per-KPI surrogate and effect shares")
+    for kpi in KPIS:
+        y = np.array([r["kpis"].get(kpi) for r in recs], float)
+        ok = np.isfinite(y)
+        if ok.sum() < 40:
+            print(f"    {kpi:22s} SKIP ({int(ok.sum())} finite values)")
+            continue
+        f_abs = (floor["per_kpi"].get(kpi) or {}).get("floor")
+        f_rel = (floor["per_kpi"].get(kpi) or {}).get("rel_floor_pct")
+        surr = S.fit(X[ok], y[ok], box, noise_floor=f_abs)
+        loo = surr.loo_error()
+        sh = S.effect_shares(surr, n=8192)
+        spans = S.effect_span(surr, len(VARS))
+
+        # The inert test uses the RELATIVE floor (F8): quantisation is floating-point, so the
+        # absolute floor scales with the KPI value. A fixed absolute floor would under-protect
+        # the high-value end of the box and declare effects real that are not.
+        med = float(np.median(y[ok]))
+        floor_here = (abs(med) * f_rel / 100.0) if f_rel else (f_abs or 0.0)
+        inert = [bool(s < floor_here) for s in spans]
+
+        per_kpi[kpi] = {
+            "n": int(ok.sum()),
+            "median": round(med, 6),
+            "range": [round(float(y[ok].min()), 6), round(float(y[ok].max()), 6)],
+            "loo": {k: round(v, 6) for k, v in loo.items()},
+            "floor_absolute_at_centre": f_abs,
+            "floor_relative_pct": f_rel,
+            "floor_applied_here": round(floor_here, 6),
+            "effect_span": {v: round(s, 6) for v, s in zip(VARS, spans, strict=True)},
+            "share": {v: round(s, 4) for v, s in zip(VARS, sh["share"], strict=True)},
+            "S1": {v: round(s, 4) for v, s in zip(VARS, sh["S1"], strict=True)},
+            "ST": {v: round(s, 4) for v, s in zip(VARS, sh["ST"], strict=True)},
+            "inert": dict(zip(VARS, inert, strict=True)),
+            "rank": [VARS[i] for i in np.argsort(spans)[::-1]],
+        }
+        print(f"    {kpi:22s} LOO nrmse {loo['nrmse_range'] * 100:5.2f}%  floor {floor_here:.4g}")
+        for i, v in enumerate(VARS):
+            mark = "  INERT" if inert[i] else ""
+            print(f"       {v:12s} span {spans[i]:10.4g}  share {sh['share'][i]:.3f}  ST {sh['ST'][i]:+.3f}{mark}")
+
+    # ---- inert overall: below floor for EVERY KPI ------------------------
+    inert_all = {v: all(per_kpi[k]["inert"][v] for k in per_kpi) for v in VARS}
+    print("\n  variables inert across ALL KPIs (fixed, not ranked low — guardrail 2):")
+    for v, b in inert_all.items():
+        print(f"    {v:12s} {'INERT -> fix' if b else 'active -> keep'}")
+
+    # ---- feasibility map -------------------------------------------------
+    nf = np.array([r["kpis"][GATE_KPI] for r in recs], float)
+    nf_arr = np.array([r["kpis"]["no_flow_margin_K"] for r in recs], float)
+    froz = np.array([r["kpis"]["frozen_fraction_end"] for r in recs], float)
+    hot = np.array([r["kpis"]["hotspot"] for r in recs], float)
+    p80 = np.array([r["kpis"]["p80_bar"] for r in recs], float)
+    resid = np.array([r["kpis"]["fill_residual"] for r in recs], float)
+
+    red_freeze = nf < NO_FLOW_END_MIN_K
+    hot_cut = float(np.quantile(hot, 1 - HOTSPOT_WORST_FRACTION))
+    p80_cut = float(np.quantile(p80, 1 - P80_WORST_FRACTION))
+    amber_hot = (hot > hot_cut) & ~red_freeze
+    amber_p80 = (p80 > p80_cut) & ~red_freeze & ~amber_hot
+    green = ~red_freeze & ~amber_hot & ~amber_p80
+
+    print(f"\n  feasibility map over {len(recs)} points")
+    print(
+        f"    {GATE_KPI} observed {nf.min():.1f} .. {nf.max():.1f} K   "
+        f"frozen fraction {froz.min():.3f} .. {froz.max():.3f}"
+    )
+    print(f"    at-arrival reading (secondary) {nf_arr.min():.1f} .. {nf_arr.max():.1f} K")
+    print(
+        f"    RED   freeze-off ({GATE_KPI} < {NO_FLOW_END_MIN_K:.0f} K)  {red_freeze.sum():5d}"
+        f"  {100 * red_freeze.mean():5.1f}%"
+    )
+    print(
+        f"    AMBER hotspot worst {HOTSPOT_WORST_FRACTION:.0%} (> {hot_cut:.4f})       "
+        f"{amber_hot.sum():5d}  {100 * amber_hot.mean():5.1f}%"
+    )
+    print(
+        f"    AMBER p80 worst {P80_WORST_FRACTION:.0%} rank (> {p80_cut:.1f} bar)  "
+        f"{amber_p80.sum():5d}  {100 * amber_p80.mean():5.1f}%"
+    )
+    print(f"    GREEN                                        {green.sum():5d}  {100 * green.mean():5.1f}%")
+    print(f"    (short shot is NOT a gate: residual max {resid.max():.4f} — see decisions D4)")
+
+    if green.sum():
+        print("\n  green-region extent (survivors only):")
+        for i, v in enumerate(VARS):
+            print(f"    {v:12s} {X[green, i].min():8.2f} .. {X[green, i].max():8.2f}")
+
+    out = {
+        "stage": "G2_screening",
+        "generated_at": datetime.now(UTC).isoformat(),
+        "source_stage": args.stage,
+        "n_runs": len(recs),
+        "observed_box": {v: [round(float(box[i, 0]), 4), round(float(box[i, 1]), 4)] for i, v in enumerate(VARS)},
+        "acceptance_criteria": CRITERIA,
+        "per_kpi": per_kpi,
+        "inert_across_all_kpis": inert_all,
+        "feasibility": {
+            "red_freeze_off": int(red_freeze.sum()),
+            "amber_hotspot": int(amber_hot.sum()),
+            "amber_pressure_rank": int(amber_p80.sum()),
+            "green": int(green.sum()),
+            "green_fraction": round(float(green.mean()), 4),
+            "gate_kpi": GATE_KPI,
+            "cuts": {
+                "no_flow_end_min_K": NO_FLOW_END_MIN_K,
+                "no_flow_at_arrival_secondary_K": NO_FLOW_MIN_K,
+                "hotspot_cut": round(hot_cut, 6),
+                "p80_cut_bar": round(p80_cut, 3),
+            },
+            "gate_observed_K": [round(float(nf.min()), 3), round(float(nf.max()), 3)],
+            "frozen_fraction_observed": [round(float(froz.min()), 5), round(float(froz.max()), 5)],
+            "at_arrival_observed_K": [round(float(nf_arr.min()), 3), round(float(nf_arr.max()), 3)],
+            "green_extent": (
+                {
+                    v: [round(float(X[green, i].min()), 4), round(float(X[green, i].max()), 4)]
+                    for i, v in enumerate(VARS)
+                }
+                if green.sum()
+                else None
+            ),
+        },
+        "fill_completeness_diagnostic": {
+            "residual_max": round(float(resid.max()), 6),
+            "residual_flow_dependence": None if resid.max() <= 0 else "see correlation below",
+            "used_as_gate": False,
+            "note": (
+                "Residual unfilled fraction is a known model bug and is identically 0 here, "
+                "so it carries no information. Gate is the no-flow margin (D4)."
+            ),
+        },
+    }
+    dest = stage_dir / "g2_screening.json"
+    dest.write_text(json.dumps(out, indent=2))
+    print(f"\n  wrote {dest.relative_to(ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,166 @@
+"""G1: the wide Sobol sweep over the ±box, live against the AI solver.
+
+Resumable by construction — every run's id is a hash of its inputs, so re-running this command
+after a crash picks up exactly where it stopped. Sobol is incremental, so `--n` can be raised
+later without invalidating anything already computed (`sobol(2n)[:n] == sobol(n)`, asserted in
+`test_design.py`).
+
+**No raw results are kept.** The storage policy says keep boundary runs, but which runs are on
+the boundary is not known until G2 has screened. Guessing now would keep the wrong ones. Since
+the solver is deterministic, re-running a specific point later returns a bit-identical result
+for ~10 s — strictly better than retaining 30 GB on a guess. G2 re-requests the handful it needs
+with `keep_h5=True`.
+
+Run:  python main.py sweep [--n 1024] [configs/simple-plate.yaml]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import numpy as np
+
+from .design import scale_to_box, sobol
+from .harness import RunSpec
+from .setup_campaign import build, resolve_config
+
+ROOT = Path(__file__).resolve().parents[1]
+
+STAGE = "G1_wide_sweep"
+ORDER = ("melt_C", "wall_C", "flow_cm3_s")
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G1 wide Sobol sweep")
+    ap.add_argument(
+        "config",
+        nargs="?",
+        help="campaign config; defaults to configs/simple-plate.yaml while that is unambiguous",
+    )
+    ap.add_argument("--n", type=int, default=None, help="override sweep_points")
+    ap.add_argument("--workers", type=int, default=None, help="override max_concurrency")
+    args = ap.parse_args()
+
+    campaign, info = build(resolve_config(args.config))
+    try:
+        cfg = info["cfg"]
+        n = int(args.n or cfg["budget"]["sweep_points"])
+        workers = int(args.workers or cfg["solver"]["max_concurrency"])
+        box = {k: tuple(info["box"][k]) for k in ORDER}
+
+        print(f"\n  G1 wide box (basis: {info['box']['basis']}):")
+        for k in ORDER:
+            print(f"    {k:12s} {box[k][0]:8.2f} .. {box[k][1]:8.2f}")
+
+        unit = sobol(n, len(ORDER))
+        cols = scale_to_box(unit, box, ORDER)
+        specs = [
+            RunSpec(
+                melt_C=float(cols["melt_C"][i]),
+                wall_C=float(cols["wall_C"][i]),
+                flow_cm3_s=round(float(cols["flow_cm3_s"][i]), 4),
+                stage=STAGE,
+                label=f"sobol{i:04d}",
+                meta={"sobol_index": i},
+            )
+            for i in range(n)
+        ]
+
+        # Process() rejects wall >= melt. The box cannot produce that (mould max 60 C < melt
+        # min 220 C), but assert rather than assume — a different material card could.
+        bad = [s for s in specs if s.wall_C >= s.melt_C]
+        if bad:
+            raise SystemExit(f"{len(bad)} design points have wall >= melt; check the box")
+
+        print(
+            f"\n  {n} Sobol points, concurrency {workers}, ~29 MB per result "
+            f"(downloaded to scratch outside OneDrive, scored, deleted)"
+        )
+        records = campaign.run_batch(
+            specs,
+            stage=STAGE,
+            max_workers=workers,
+            description=f"G1 wide sweep: {n}-point Sobol over the material-card temperature "
+            f"window and nominal +/-50 % flow. Incremental and resumable.",
+        )
+
+        ok = [r for r in records if r.ok]
+        print(f"\n  {len(ok)}/{len(records)} scored")
+        if ok:
+            p80 = np.array([r.kpis["p80_bar"] for r in ok], float)
+            nf = np.array([r.kpis["no_flow_margin"] for r in ok], float)
+            res = np.array([r.kpis["fill_residual"] for r in ok], float)
+            hot = np.array([r.kpis["hotspot"] for r in ok], float)
+            print(
+                f"    p80            {p80.min():8.2f} .. {p80.max():8.2f} bar "
+                f"(median {np.median(p80):.2f}, spread x{p80.max() / max(p80.min(), 1e-9):.2f})"
+            )
+            print(
+                f"    no_flow_margin {nf.min():8.4f} .. {nf.max():8.4f} "
+                f"(negative = freeze-off: {int((nf < 0).sum())} runs)"
+            )
+            print(f"    hotspot        {hot.min():8.4f} .. {hot.max():8.4f}")
+            print(f"    fill_residual  {res.min():8.4f} .. {res.max():8.4f} (>0 on {int((res > 0).sum())} runs)")
+
+        manifest = {
+            "stage": STAGE,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "design": {
+                "type": "sobol",
+                "n": n,
+                "dims": list(ORDER),
+                "skip": 0,
+                "incremental": "sobol(2n)[:n] == sobol(n)",
+            },
+            "box": {k: list(box[k]) for k in ORDER},
+            "box_basis": info["box"]["basis"],
+            "centre": info["box"]["centre_C"],
+            "solver": {
+                "model_version": campaign.model_version,
+                "num_timesteps": campaign.num_timesteps,
+                "htc_W_m2K": campaign.htc_W_m2K,
+            },
+            "geometry_id": info["geometry_id"],
+            "project_id": info["project_id"],
+            "n_ok": len(ok),
+            "n_total": len(records),
+            "runs": [
+                {
+                    "run_id": r.run_id,
+                    "sobol_index": (r.spec.get("meta") or {}).get("sobol_index"),
+                    "melt_C": r.spec["melt_C"],
+                    "wall_C": r.spec["wall_C"],
+                    "flow_cm3_s": r.spec["flow_cm3_s"],
+                    "simulation_id": r.simulation_id,
+                    "ok": r.ok,
+                    "error": r.error or None,
+                    "kpis": r.kpis,
+                }
+                for r in records
+            ],
+        }
+        dest = info["stage_dir"] / "g1_sweep.json"
+        dest.write_text(json.dumps(manifest, indent=2))
+        print(f"\n  wrote {dest.relative_to(ROOT)}")
+
+        if ok:
+            campaign.note(
+                f"G1 wide sweep: {len(ok)}/{len(records)} Sobol points over melt "
+                f"{box['melt_C'][0]:.0f}-{box['melt_C'][1]:.0f} C (material card window), wall "
+                f"{box['wall_C'][0]:.0f}-{box['wall_C'][1]:.0f} C, flow "
+                f"{box['flow_cm3_s'][0]:.2f}-{box['flow_cm3_s'][1]:.2f} cm3/s (nominal +/-50 %). "
+                f"p80 spans {p80.min():.1f}-{p80.max():.1f} bar (ordering only). "
+                f"{int((nf < 0).sum())} points show freeze-off (negative no-flow margin). "
+                f"Raw results discarded after scoring; deterministic solver makes targeted "
+                f"re-runs free."
+            )
+    finally:
+        info["api"].close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())