simcon-toolkit 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,322 @@
+"""Feedback path: anchor calibration and self-diagnosis, on fake-real data.
+
+The brief asks for a step that takes a small set of "real" results, computes the AI-to-reality
+offset at 3 anchor points, and classifies the spread green / warn / alarm — with thresholds
+derived from the data, not imported.
+
+**How "reality" is faked, and what that does and does not prove.** There is no machine data, and
+numerical execution is out of scope this session. So reality is generated by running the solver
+with **hidden input deviations the DOE side never sees**: the DOE believes it asked for one thing,
+reality was actually something else. Three deviations, as the brief specifies:
+
+  * `melt_shift`     — the barrel really runs 6 K colder than the setpoint says
+  * `moved_gate`     — the gate is not where the model puts it
+  * `material_swap`  — a different grade than the one on the datasheet
+
+This exercises the whole calibration and classification path and derives real thresholds. Its
+limitation must be stated wherever the result is used: **it measures the pipeline's sensitivity to
+input misspecification, not the AI-to-physics offset.** When the numerical solver is available the
+source of "reality" swaps and nothing else changes.
+
+**What the classifier actually tests.** Not "is the AI accurate" — the whole method is
+ordering-based, so accuracy is the wrong question. Two things matter:
+
+  1. **Is the offset a constant?** If reality differs from the AI by a fixed amount, every rank,
+     ratio and comparison survives and the method is unaffected. The test is whether the spread of
+     offsets across anchors is distinguishable from the KPI's own derived resolution floor.
+  2. **Does the ordering survive?** Pairwise sign agreement between AI and reality across the
+     anchors. This is the property every claim in the dossier rests on, so it is checked directly
+     rather than inferred.
+
+Run:  python main.py feedback configs/simple-plate.yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import itertools
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import numpy as np
+
+from .harness import RunSpec
+from .run_screening import GATE_KPI, VARS
+from .setup_campaign import build, resolve_config
+
+ROOT = Path(__file__).resolve().parents[1]
+
+STAGE = "G6_feedback"
+MELT_SHIFT_K = -6.0  # a plausible, invisible barrel/setpoint discrepancy
+CALIB_KPIS = ("p80_bar", GATE_KPI, "hotspot")
+
+
+def anchors_from_g3(g3: dict, box: dict) -> list[dict]:
+    """Three anchors: the centre and two interior points well separated from it.
+
+    Spread matters more than count here — three anchors that sit almost on top of each other
+    cannot distinguish a constant offset from a distortion, which is the whole question.
+    """
+    c = {v: float(g3["centre"][v]) for v in VARS}
+    rb = {v: [float(x) for x in g3["recommended_box"][v]] for v in VARS}
+
+    def lerp(v, f):
+        return rb[v][0] + f * (rb[v][1] - rb[v][0])
+
+    return [
+        {"id": "A0_centre", **c},
+        {
+            "id": "A1_cool_slow",
+            "melt_C": lerp("melt_C", 0.2),
+            "wall_C": lerp("wall_C", 0.2),
+            "flow_cm3_s": lerp("flow_cm3_s", 0.2),
+        },
+        {
+            "id": "A2_hot_fast",
+            "melt_C": lerp("melt_C", 0.8),
+            "wall_C": lerp("wall_C", 0.8),
+            "flow_cm3_s": lerp("flow_cm3_s", 0.8),
+        },
+    ]
+
+
+def classify(offsets: np.ndarray, floor: float) -> tuple[str, dict]:
+    """green / warn / alarm from the spread of offsets, in units of the DERIVED floor.
+
+    The unit is derived from this part's own epsilon experiment — that is what makes the
+    thresholds data-derived rather than imported. The multipliers are a stated judgement:
+
+      spread <= 1 floor  -> the offset is indistinguishable from a constant. Every rank, ratio and
+                            comparison survives, so the method is unaffected.  GREEN
+      spread <= 3 floors -> a real but modest point-dependence. A single calibration constant is
+                            imperfect; ordering probably survives but should be re-checked.  WARN
+      spread  > 3 floors -> the offset varies more than three times the resolution limit, so no
+                            single calibration works and the distortion may reorder points.  ALARM
+    """
+    spread = float(np.max(offsets) - np.min(offsets))
+    ratio = spread / max(floor, 1e-12)
+    verdict = "green" if ratio <= 1.0 else ("warn" if ratio <= 3.0 else "alarm")
+    return verdict, {
+        "mean_offset": round(float(np.mean(offsets)), 6),
+        "spread": round(spread, 6),
+        "floor": round(float(floor), 6),
+        "spread_in_floors": round(ratio, 3),
+        "constant_offset_hypothesis": (
+            "indistinguishable from constant" if ratio <= 1.0 else "rejected: offset is point-dependent"
+        ),
+    }
+
+
+def ordering_agreement(ai: np.ndarray, real: np.ndarray, floor: float) -> dict:
+    """Pairwise sign agreement, ignoring pairs the AI itself cannot resolve.
+
+    A pair whose AI difference is below the resolution floor carries no ordering claim, so
+    counting it as agreement or disagreement would both be wrong. Those pairs are reported
+    separately as unresolvable.
+    """
+    agree = disagree = unresolvable = 0
+    for i, j in itertools.combinations(range(len(ai)), 2):
+        d_ai = ai[i] - ai[j]
+        if abs(d_ai) < floor:
+            unresolvable += 1
+            continue
+        if np.sign(d_ai) == np.sign(real[i] - real[j]):
+            agree += 1
+        else:
+            disagree += 1
+    total = agree + disagree
+    return {
+        "pairs_agree": agree,
+        "pairs_disagree": disagree,
+        "pairs_unresolvable_by_ai": unresolvable,
+        "agreement": round(agree / total, 3) if total else None,
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G6 fake-real feedback + self-diagnosis")
+    ap.add_argument(
+        "config",
+        nargs="?",
+        help="campaign config; defaults to configs/simple-plate.yaml while that is unambiguous",
+    )
+    args = ap.parse_args()
+
+    campaign, info = build(resolve_config(args.config))
+    try:
+        stage_dir = info["stage_dir"]
+        g3_path = stage_dir / "g3_refinement.json"
+        if not g3_path.exists():
+            print(f"  need {g3_path.relative_to(ROOT)} — run `python main.py refine` first")
+            return 1
+        g3 = json.loads(g3_path.read_text())
+        floors = json.loads((stage_dir / "noise_floor.json").read_text())["per_kpi"]
+        anchors = anchors_from_g3(g3, info["box"])
+
+        # A different grade for the material swap. Chosen as another PP so the deviation is
+        # plausible-but-invisible rather than absurd; a wildly different family would be a
+        # strawman the classifier could not fail to catch.
+        alt = None
+        for q in ("PP", "PP Generic"):
+            for m in campaign.api.search_materials(q, limit=60):
+                if m["material_id"] != info["material_id"] and (m.get("family") or "").upper() == "PP":
+                    alt = m
+                    break
+            if alt:
+                break
+        # A moved gate: shift to a different real mesh node, ~2 mm away.
+        import numpy as _np
+
+        from cadmould_geometry.mesh import parse_cfex_nodes
+
+        nodes = parse_cfex_nodes(info["cfex"])
+        g0 = _np.array(info["gates_mm"][0], float)
+        d = _np.linalg.norm(nodes - g0, axis=1)
+        moved = nodes[int(_np.argmin(_np.abs(d - 2.0)))]
+
+        deviations = [
+            ("baseline", {}, "what the DOE side believes it asked for"),
+            (
+                "melt_shift",
+                {"melt_delta_C": MELT_SHIFT_K},
+                f"barrel actually {abs(MELT_SHIFT_K):.0f} K colder than the setpoint",
+            ),
+            (
+                "moved_gate",
+                {"gates": [list(map(float, moved))]},
+                f"gate actually {float(_np.linalg.norm(moved - g0)):.2f} mm from where the model puts it",
+            ),
+        ]
+        if alt:
+            deviations.append(
+                (
+                    "material_swap",
+                    {"material_id": alt["material_id"]},
+                    f"grade actually '{alt['trade_name']}', not '{info['cfg']['material']['catalogue_name']}'",
+                )
+            )
+        print(f"\n  {len(anchors)} anchors x {len(deviations)} variants = {len(anchors) * len(deviations)} runs")
+        for name, _, why in deviations:
+            print(f"    {name:14s} {why}")
+
+        specs = []
+        for a in anchors:
+            for name, dev, _ in deviations:
+                specs.append(
+                    RunSpec(
+                        melt_C=a["melt_C"] + dev.get("melt_delta_C", 0.0),
+                        wall_C=a["wall_C"],
+                        flow_cm3_s=round(a["flow_cm3_s"], 4),
+                        stage=STAGE,
+                        label=f"{a['id']}|{name}",
+                        material_id_override=dev.get("material_id"),
+                        gates_mm_override=tuple(map(tuple, dev["gates"])) if dev.get("gates") else None,
+                        meta={"anchor": a["id"], "deviation": name},
+                    )
+                )
+
+        recs = campaign.run_batch(
+            specs,
+            stage=STAGE,
+            max_workers=int(info["cfg"]["solver"]["max_concurrency"]),
+            description="Fake-real feedback: hidden input deviations the DOE "
+            "side never sees, for anchor calibration and "
+            "self-diagnosis.",
+        )
+        by = {(r.spec["meta"]["anchor"], r.spec["meta"]["deviation"]): r for r in recs if r.ok}
+
+        report: dict = {
+            "stage": STAGE,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "fake_real_source": "ai_with_hidden_deviation",
+            "limitation": (
+                "Measures the pipeline's sensitivity to input "
+                "misspecification, NOT the AI-to-physics offset. Swap in "
+                "numerical runs when available; nothing else changes."
+            ),
+            "anchors": anchors,
+            "deviations": [{"name": n, "detail": w} for n, _, w in deviations],
+            "per_deviation": {},
+        }
+
+        overall = []
+        for name, _, why in deviations:
+            if name == "baseline":
+                continue
+            block = {"detail": why, "per_kpi": {}}
+            print(f"\n  === {name}: {why} ===")
+            for kpi in CALIB_KPIS:
+                floor = float(floors[kpi]["floor"])
+                ai, real, ids = [], [], []
+                for a in anchors:
+                    b = by.get((a["id"], "baseline"))
+                    r = by.get((a["id"], name))
+                    if not b or not r:
+                        continue
+                    va, vr = b.kpis.get(kpi), r.kpis.get(kpi)
+                    if va is None or vr is None:
+                        continue
+                    ai.append(float(va))
+                    real.append(float(vr))
+                    ids.append(a["id"])
+                if len(ai) < 2:
+                    block["per_kpi"][kpi] = {"error": "insufficient successful anchors"}
+                    print(f"    {kpi:22s} insufficient data")
+                    continue
+                ai_a, real_a = np.array(ai), np.array(real)
+                off = real_a - ai_a
+                verdict, stats = classify(off, floor)
+                order = ordering_agreement(ai_a, real_a, floor)
+                block["per_kpi"][kpi] = {
+                    "anchors": ids,
+                    "ai": [round(x, 4) for x in ai],
+                    "reality": [round(x, 4) for x in real],
+                    "offsets": [round(x, 4) for x in off.tolist()],
+                    "verdict": verdict,
+                    **stats,
+                    "ordering": order,
+                }
+                overall.append(verdict)
+                print(
+                    f"    {kpi:22s} offset mean {stats['mean_offset']:+9.3f}  "
+                    f"spread {stats['spread']:8.3f} = {stats['spread_in_floors']:5.2f} floors  "
+                    f"-> {verdict.upper():5s}  ordering {order['agreement']} "
+                    f"({order['pairs_unresolvable_by_ai']} unresolvable)"
+                )
+            report["per_deviation"][name] = block
+
+        rank = {"green": 0, "warn": 1, "alarm": 2}
+        final = max(overall, key=lambda v: rank[v]) if overall else "insufficient"
+        report["self_diagnosis"] = {
+            "verdict": final,
+            "basis": "worst per-KPI verdict across all deviations",
+            "thresholds": {
+                "green": "offset spread <= 1 x derived floor",
+                "warn": "<= 3 x derived floor",
+                "alarm": "> 3 x derived floor",
+            },
+            "threshold_basis": (
+                "the UNIT is this part's own epsilon-derived resolution floor; the "
+                "multipliers 1 and 3 are a stated judgement, not measured"
+            ),
+        }
+        print(f"\n  SELF-DIAGNOSIS: {final.upper()}  (worst KPI across all deviations)")
+
+        (stage_dir / "g6_feedback.json").write_text(json.dumps(report, indent=2))
+        print(f"  wrote {(stage_dir / 'g6_feedback.json').relative_to(ROOT)}")
+
+        campaign.note(
+            f"G6 feedback loop: {len(anchors)} anchors x {len(deviations)} variants. Reality faked "
+            f"by hidden input deviations the DOE side never sees (melt shift, moved gate"
+            f"{', material swap' if alt else ''}). Self-diagnosis: {final.upper()}. Thresholds in "
+            f"units of this part's derived resolution floor. LIMITATION: measures sensitivity to "
+            f"input misspecification, not the AI-to-physics offset."
+        )
+    finally:
+        info["api"].close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,279 @@
+"""G3: adaptive refinement of the feasibility boundary, then the centre point.
+
+Places further AI runs where the surrogate is **uncertain** *and* the **boundary is near** —
+dense where the response is steep, sparse where it is flat, which is what the brief asks for. The
+acquisition score is
+
+    score = posterior_variance ^ w_var  *  boundary_proximity ^ w_bnd
+
+with boundary proximity as a narrow kernel on the signed distance to the gate, measured in units
+of the derived KPI floor: a point is "near the boundary" if the surrogate cannot tell which side
+of the gate it is on. That ties the refinement directly to the measured resolution limit rather
+than to an arbitrary band.
+
+Candidates are drawn from the *continuation of the same Sobol sequence*, so the refinement points
+inherit the design's space-filling property instead of clumping, and the whole campaign remains
+one extensible sequence.
+
+Run:  python main.py refine configs/simple-plate.yaml [--n 384]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import numpy as np
+
+from . import centre as C, surrogate as S
+from .design import scale_to_box, sobol
+from .harness import RunSpec
+from .run_screening import GATE_KPI, NO_FLOW_END_MIN_K, VARS, load_records
+from .setup_campaign import build, resolve_config
+
+ROOT = Path(__file__).resolve().parents[1]
+
+STAGE = "G3_refinement"
+SWEEP_STAGE = "G1_wide_sweep"
+
+
+def acquisition(
+    surr, cand_unit: np.ndarray, gate: float, floor: float, *, w_var: float = 0.5, w_bnd: float = 1.0
+) -> np.ndarray:
+    """Uncertainty x boundary-proximity, both normalised to [0,1]."""
+    var = surr.variance_unit(cand_unit)
+    var = var / max(float(var.max()), 1e-12)
+
+    pred = surr.predict_unit(cand_unit)
+    # Distance to the gate in units of the resolution floor. Within ~1 floor of the gate the
+    # surrogate genuinely cannot say which side a point is on — that is where a run buys the most.
+    z = np.abs(pred - gate) / max(floor, 1e-9)
+    prox = np.exp(-0.5 * (z / 2.0) ** 2)
+
+    return (var**w_var) * (prox**w_bnd)
+
+
+def pick(
+    surr,
+    box: np.ndarray,
+    n: int,
+    gate: float,
+    floor: float,
+    *,
+    pool: int = 20000,
+    start: int = 4096,
+    min_sep: float = 0.02,
+) -> tuple[np.ndarray, dict]:
+    """Choose n candidates by acquisition, with a minimum separation so they do not stack up."""
+    cand = sobol(pool + start, len(box))[start:]  # continuation of the same sequence
+    score = acquisition(surr, cand, gate, floor)
+    order = np.argsort(score)[::-1]
+    chosen: list[int] = []
+    for i in order:
+        if len(chosen) >= n:
+            break
+        if all(np.max(np.abs(cand[i] - cand[j])) > min_sep for j in chosen):
+            chosen.append(int(i))
+    idx = np.array(chosen)
+    diag = {
+        "pool": pool,
+        "sobol_offset": start,
+        "min_separation_unit": min_sep,
+        "score_range": [round(float(score[idx].min()), 6), round(float(score[idx].max()), 6)],
+        "n_selected": len(idx),
+    }
+    return cand[idx], diag
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="G3 boundary refinement + centre point")
+    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)
+    ap.add_argument("--grid", type=int, default=41)
+    ap.add_argument("--no-run", action="store_true", help="fit and solve only; submit nothing")
+    args = ap.parse_args()
+
+    campaign, info = build(resolve_config(args.config))
+    try:
+        cfg = info["cfg"]
+        runs_dir, stage_dir = info["runs_dir"], info["stage_dir"]
+        n_ref = int(args.n or cfg["budget"]["refine_points"])
+
+        floor_all = json.loads((stage_dir / "noise_floor.json").read_text())["per_kpi"]
+        recs = load_records(runs_dir, SWEEP_STAGE) + load_records(runs_dir, STAGE)
+        if len(recs) < 100:
+            print(f"  only {len(recs)} scored runs; let G1 progress further first")
+            return 1
+        print(f"  fitting on {len(recs)} runs ({SWEEP_STAGE} + any prior {STAGE})")
+
+        X = np.array([[r["spec"][v] for v in VARS] for r in recs], float)
+        box = np.array([tuple(info["box"][v]) for v in VARS], float)
+
+        y_gate = np.array([r["kpis"][GATE_KPI] for r in recs], float)
+        ok = np.isfinite(y_gate)
+        f_gate = floor_all[GATE_KPI]["floor"]
+        surr_gate = S.fit(X[ok], y_gate[ok], box, noise_floor=f_gate)
+        print(
+            f"  {GATE_KPI}: LOO nrmse {surr_gate.loo_error()['nrmse_range'] * 100:.2f}%, "
+            f"floor {f_gate:.4g} K, observed {y_gate[ok].min():.1f}..{y_gate[ok].max():.1f} K"
+        )
+
+        # ---- submit refinement runs -------------------------------------
+        if not args.no_run:
+            cand, diag = pick(surr_gate, box, n_ref, NO_FLOW_END_MIN_K, f_gate)
+            cols = scale_to_box(cand, {v: tuple(box[i]) for i, v in enumerate(VARS)}, VARS)
+            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"refine{i:04d}",
+                    meta={"acquisition": True},
+                )
+                for i in range(len(cand))
+            ]
+            print(
+                f"  {len(specs)} refinement points selected "
+                f"(uncertainty x boundary-proximity within ~2 floors of the {NO_FLOW_END_MIN_K} K gate)"
+            )
+            campaign.run_batch(
+                specs,
+                stage=STAGE,
+                max_workers=int(cfg["solver"]["max_concurrency"]),
+                description=f"G3 adaptive refinement near the {GATE_KPI} = {NO_FLOW_END_MIN_K} K feasibility boundary.",
+            )
+            recs = load_records(runs_dir, SWEEP_STAGE) + load_records(runs_dir, STAGE)
+            X = np.array([[r["spec"][v] for v in VARS] for r in recs], float)
+            y_gate = np.array([r["kpis"][GATE_KPI] for r in recs], float)
+            ok = np.isfinite(y_gate)
+            surr_gate = S.fit(X[ok], y_gate[ok], box, noise_floor=f_gate)
+            print(f"  refit on {len(recs)} runs: LOO nrmse {surr_gate.loo_error()['nrmse_range'] * 100:.2f}%")
+
+        # ---- green region + Chebyshev centre ----------------------------
+        # Every criterion becomes a Constraint carrying its own threshold and its own derived
+        # resolution band, so the solver can tell which one actually binds at the centre and take
+        # the margin from that one. Amber quality cuts are percentiles of the observed sample
+        # (rank-based, per guardrail 1).
+        y_hot = np.array([r["kpis"]["hotspot"] for r in recs], float)
+        y_p80 = np.array([r["kpis"]["p80_bar"] for r in recs], float)
+        surr_hot = S.fit(X, y_hot, box, noise_floor=floor_all["hotspot"]["floor"])
+        surr_p80 = S.fit(X, y_p80, box, noise_floor=floor_all["p80_bar"]["floor"])
+        hot_cut = float(np.quantile(y_hot, 0.90))
+        p80_cut = float(np.quantile(y_p80, 0.90))
+
+        cons = [
+            C.Constraint(
+                GATE_KPI,
+                surr_gate,
+                NO_FLOW_END_MIN_K,
+                "min",
+                float(f_gate),
+                effect_span=np.array(S.effect_span(surr_gate, len(VARS)), float),
+            ),
+            C.Constraint(
+                "hotspot",
+                surr_hot,
+                hot_cut,
+                "max",
+                float(floor_all["hotspot"]["floor"]),
+                effect_span=np.array(S.effect_span(surr_hot, len(VARS)), float),
+            ),
+            C.Constraint(
+                "p80_bar",
+                surr_p80,
+                p80_cut,
+                "max",
+                float(floor_all["p80_bar"]["floor"]),
+                effect_span=np.array(S.effect_span(surr_p80, len(VARS)), float),
+            ),
+        ]
+        for c in cons:
+            print(
+                f"  constraint {c.name:18s} {c.sense} {c.threshold:9.4g}  band {c.band:.4g}  "
+                "span " + ", ".join(f"{v}={c.effect_span[i]:.3g}" for i, v in enumerate(VARS))
+            )
+
+        g = C.solve(constraints=cons, box=box, var_names=VARS, grid_n=args.grid)
+
+        print(f"\n  green region: {100 * g.feasible_fraction:.1f}% of the box (grid {args.grid}^{len(VARS)})")
+        print(f"  binding constraint at centre: {g.binding_constraint}")
+        for note in g.notes:
+            print(f"    NOTE: {note}")
+        if np.all(np.isfinite(g.centre_phys)):
+            print(f"\n  Chebyshev centre (deepest interior point, inradius {g.inradius_unit:.3f} normalised):")
+            for i, v in enumerate(VARS):
+                print(f"    {v:12s} {g.centre_phys[i]:8.3f}   margin +/- {g.margin_phys[i]:.3f}")
+            print("\n  recommended box after inward shrink by the margin:")
+            for i, v in enumerate(VARS):
+                print(f"    {v:12s} {g.shrunk_box_phys[i, 0]:8.3f} .. {g.shrunk_box_phys[i, 1]:8.3f}")
+            print(f"  limiting variable: {g.limiting_variable}")
+
+        out = {
+            "stage": STAGE,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "n_runs_used": len(recs),
+            "gate_kpi": GATE_KPI,
+            "gate_value_K": NO_FLOW_END_MIN_K,
+            "binding_constraint": g.binding_constraint,
+            "slack_at_centre_bands": {k: round(v, 3) for k, v in g.slack_at_centre.items()},
+            "band_basis": (
+                "each constraint carries its own derived resolution floor for this "
+                "part; the AI-to-numerical disagreement from G4 must be added once "
+                "available"
+            ),
+            "surrogates": {
+                GATE_KPI: {"loo": surr_gate.loo_error(), "floor": f_gate},
+                "hotspot": {"loo": surr_hot.loo_error(), "cut": round(hot_cut, 6)},
+                "p80_bar": {"loo": surr_p80.loo_error(), "cut_bar": round(p80_cut, 3)},
+            },
+            "green_fraction": round(g.feasible_fraction, 4),
+            "centre": {
+                "definition": "chebyshev_centre_shrunk",
+                **{v: round(float(g.centre_phys[i]), 4) for i, v in enumerate(VARS)},
+            },
+            "inradius_unit": round(g.inradius_unit, 5),
+            "margin_variable_space": {v: round(float(g.margin_phys[i]), 4) for i, v in enumerate(VARS)},
+            "constraints": [
+                {
+                    "name": c.name,
+                    "sense": c.sense,
+                    "threshold": round(float(c.threshold), 6),
+                    "band": round(float(c.band), 6),
+                    "effect_span": {v: round(float(c.effect_span[i]), 4) for i, v in enumerate(VARS)},
+                }
+                for c in cons
+            ],
+            "recommended_box": {
+                v: [round(float(g.shrunk_box_phys[i, 0]), 4), round(float(g.shrunk_box_phys[i, 1]), 4)]
+                for i, v in enumerate(VARS)
+            },
+            "limiting_variable": g.limiting_variable,
+            "notes": g.notes,
+        }
+        (stage_dir / "g3_refinement.json").write_text(json.dumps(out, indent=2))
+        print(f"\n  wrote {(stage_dir / 'g3_refinement.json').relative_to(ROOT)}")
+
+        if np.all(np.isfinite(g.centre_phys)):
+            campaign.note(
+                f"G3: green region {100 * g.feasible_fraction:.1f}% of the wide box over "
+                f"{len(recs)} AI runs. Chebyshev centre (deepest interior point, NOT the survivor "
+                f"mean) at melt {g.centre_phys[0]:.1f} C / wall {g.centre_phys[1]:.1f} C / "
+                f"Q {g.centre_phys[2]:.3f} cm3/s. Binding constraint: {g.binding_constraint}. "
+                f"Margin in variable space via that constraint's local gradient: "
+                f"+/-{g.margin_phys[0]:.2f} C, +/-{g.margin_phys[1]:.2f} C, "
+                f"+/-{g.margin_phys[2]:.3f} cm3/s. Limiting variable: {g.limiting_variable}."
+            )
+    finally:
+        info["api"].close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())