simcon-toolkit 0.1.0__py3-none-any.whl

simcon_toolkit/_kit/templates/quoting/quoting/study.py

@@ -0,0 +1,577 @@
+"""The cloud side of a quote: mesh once, then buy the few decisions that move the price.
+
+A quoting study is **not** a design study. It runs the smallest number of simulations that
+settle the questions the estimator cannot answer from the drawing:
+
+  1. **How many gates?**  -> hot-runner nozzles x cavities, i.e. real money on the tool.
+  2. **What cavity pressure?** -> clamp force -> which press -> the hourly rate.
+  3. **How fast can it be filled?** -> the fill part of the cycle, and the shear ceiling.
+
+Everything else (weld position, fill balance) is scored because it is free once the run exists,
+and because a weld line on a functional face is a quality risk that belongs on the quote's
+assumptions slide rather than in a surprise at first article.
+
+Units mirror the API: temperatures K, pressure Pa, spatial mm, flow cm3/s.
+"""
+
+from __future__ import annotations
+
+import concurrent.futures as cf
+import os
+import re
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+import httpx
+import numpy as np
+
+from cadmould_geometry import stl as stl_reader
+
+from . import toolkit as T
+
+MODEL_VERSION = "v0.1.0"
+NUM_TIMESTEPS = 50
+HTC_W_M2K = 1000.0
+
+# Thermal data by material family, used only when the platform's material-version payload does
+# not carry it (it usually does - lambda_W_mK / cp_J_kgK / melt_density_kg_m3 /
+# no_flow_temperature_K / ejection_temperature_K). Textbook values, good enough for a cycle-time
+# estimate, not good enough for a warranty.
+FAMILY_THERMAL: dict[str, dict] = {
+    "PP": {"lambda_W_mK": 0.19, "cp_J_kgK": 2500, "rho_kg_m3": 750, "no_flow_K": 408.15, "eject_K": 353.15},
+    "PP-GF": {"lambda_W_mK": 0.25, "cp_J_kgK": 1800, "rho_kg_m3": 900, "no_flow_K": 418.15, "eject_K": 373.15},
+    "PA-GF": {"lambda_W_mK": 0.28, "cp_J_kgK": 1900, "rho_kg_m3": 1150, "no_flow_K": 483.15, "eject_K": 403.15},
+    "POM": {"lambda_W_mK": 0.23, "cp_J_kgK": 2100, "rho_kg_m3": 1200, "no_flow_K": 423.15, "eject_K": 373.15},
+    "ABS": {"lambda_W_mK": 0.18, "cp_J_kgK": 1900, "rho_kg_m3": 950, "no_flow_K": 393.15, "eject_K": 353.15},
+}
+DEFAULT_THERMAL = FAMILY_THERMAL["PP"]
+
+
+# ==========================================================================
+# weld consolidation
+# ==========================================================================
+# Two filters and a merge, all validated against real runs on the sample plate (1 / 2 / 3 gates).
+# Raw, the detector reported 7 / 10 / 6 weld clusters on a flat plate - a number that is worse
+# than useless on a quote, because it reads as fact. Inspecting the clusters showed what they
+# were: real weld lines at the two ends (forming at t ~ 1.43 s of a 1.46 s fill) plus clusters
+# sitting ON the gate at t ~ 0.17 s. A weld cannot form at the gate before anything has met; that
+# is the flow-direction field diverging from a point source. After filtering and merging, the
+# same runs give exactly what the physics predicts: 1 gate -> welds at both ends only; 2 gates ->
+# one interior weld at the midpoint between them; 3 gates -> two interior welds at the two
+# midpoints. The gate-study playbook says to re-validate the detector on every new part; this is
+# that re-validation, kept in code so it is not re-argued.
+EARLY_FILL_FRACTION = 0.15  # a "weld" before this share of the fill has passed is the gate
+GATE_EXCLUSION_AXIS = 0.06  # ... or one sitting this close to a gate, in normalised axis units
+MERGE_AXIS_TOLERANCE = 0.05  # clusters this close along the axis are one weld line
+END_ZONE_AXIS = 0.08  # welds within this of either end are "at the end" - normally hidden
+
+
+@dataclass
+class WeldLine:
+    """One consolidated weld line, located along the part's long axis (0..1)."""
+
+    axis_pos: float
+    n_nodes: int
+    fill_time_s: float
+    at_end: bool
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+def consolidate_welds(analysis, gate_axis_pos: list[float], total_fill_time_s: float) -> list[WeldLine]:
+    """Drop gate artefacts, merge co-located clusters, and mark which welds sit at the ends."""
+    kept = []
+    for c in analysis.weld_clusters:
+        if total_fill_time_s > 0 and c.fill_time_s < EARLY_FILL_FRACTION * total_fill_time_s:
+            continue  # nothing has met yet - this is the front leaving the gate
+        if any(abs(c.axis_pos - g) < GATE_EXCLUSION_AXIS for g in gate_axis_pos):
+            continue  # a "weld" at the gate is the gate
+        kept.append(c)
+
+    kept.sort(key=lambda c: c.axis_pos)
+    lines: list[WeldLine] = []
+    for c in kept:
+        if lines and abs(c.axis_pos - lines[-1].axis_pos) < MERGE_AXIS_TOLERANCE:
+            prev = lines[-1]
+            total = prev.n_nodes + c.n_nodes
+            prev.axis_pos = (prev.axis_pos * prev.n_nodes + c.axis_pos * c.n_nodes) / total
+            prev.fill_time_s = max(prev.fill_time_s, c.fill_time_s)
+            prev.n_nodes = total
+            prev.at_end = prev.axis_pos < END_ZONE_AXIS or prev.axis_pos > 1.0 - END_ZONE_AXIS
+            continue
+        lines.append(
+            WeldLine(
+                axis_pos=float(c.axis_pos),
+                n_nodes=int(c.n_nodes),
+                fill_time_s=float(c.fill_time_s),
+                at_end=bool(c.axis_pos < END_ZONE_AXIS or c.axis_pos > 1.0 - END_ZONE_AXIS),
+            )
+        )
+    return lines
+
+
+# ==========================================================================
+# results of the study
+# ==========================================================================
+@dataclass
+class GateOption:
+    """One gating candidate, scored. The unit the costing model prices."""
+
+    n_gates: int
+    gates_mm: list[list[float]]
+    flow_rate_cm3_s: float
+    fill_time_s: float
+    max_pressure_bar: float
+    max_shear_1s: float
+    fill_pct: float
+    tail_fraction: float
+    n_welds: int  # consolidated weld lines (gate artefacts removed)
+    weld_axis_pos: list[float] = field(default_factory=list)
+    n_interior_welds: int = 0  # the ones that do NOT sit at an end - i.e. across the part
+    n_weld_clusters_raw: int = 0  # what the detector reported before consolidation
+    short_shot: bool = False
+    simulation_id: str = ""
+    h5_path: str = ""
+    source: str = "cloud"  # "cloud" | "estimated"
+    label: str = ""
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+    def row(self) -> str:
+        return (
+            f"  {self.label or (str(self.n_gates) + ' gate'):18s} "
+            f"P={self.max_pressure_bar:7.1f} bar  shear={self.max_shear_1s:8.0f} 1/s  "
+            f"fill={self.fill_pct:5.1f}%  t={self.fill_time_s:5.2f} s  "
+            f"tail={self.tail_fraction:4.2f}  welds={self.n_welds} "
+            f"({self.n_interior_welds} interior, from {self.n_weld_clusters_raw} raw clusters)"
+        )
+
+
+@dataclass
+class MaterialResolution:
+    """A house grade resolved against the platform catalogue."""
+
+    house_name: str
+    catalogue_name: str
+    material_id: str
+    version_id: str
+    melt_K: float
+    wall_K: float
+    thermal: dict
+    source: str = "catalogue"  # thermal data: "catalogue" | "family-default"
+    matched_on: str = ""  # the query that actually hit
+    substituted: bool = False  # the house grade itself is not in the catalogue
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+    def note(self) -> str:
+        """One sentence for the quote's assumptions slide."""
+        if not self.substituted:
+            return f"Simulated with catalogue grade '{self.catalogue_name}'."
+        return (
+            f"'{self.house_name}' is not in the platform's material catalogue, so the filling "
+            f"simulation used '{self.catalogue_name}' as the nearest stand-in (matched on "
+            f"'{self.matched_on}'). Flow behaviour transfers well within a family; absolute "
+            "pressure does not, which is why the clamp force is not sized from it."
+        )
+
+
+# ==========================================================================
+# local meshing (the only step that needs the cadmould licence)
+# ==========================================================================
+@dataclass
+class MeshedPart:
+    cfex_path: Path
+    node_coords: np.ndarray
+    suggested_gate: list[float]
+    volume_cm3: float
+    long_axis: int
+    n_nodes: int
+    sdk_fill_time_s: float | None = None
+
+    def harness_geometry(self) -> T.HarnessGeometry:
+        """The shape the reused gate-placement helpers expect."""
+        return T.HarnessGeometry(self.cfex_path, self.node_coords, self.suggested_gate, self.volume_cm3, self.long_axis)
+
+
+def mesh_part(stl_path: str | Path, cfex_out: str | Path, *, logger=print) -> MeshedPart:
+    """Mesh the STL with the cadmould SDK and read the real node coordinates back.
+
+    The AI solver needs every gate to sit on an actual mesh node, and the SDK's ``Mesh`` exposes
+    no coordinate getters - so the node table is read back out of the written ``.cfex``. One
+    licence session covers the whole function; do not nest another inside it.
+    """
+    import cadmould
+
+    stl_path, cfex_out = Path(stl_path), Path(cfex_out)
+    # The kit's one STL reader: a gate is stored as an index into this vertex array, so
+    # every template must fold and order the vertices the same way.
+    pts, faces = stl_reader.read_stl(stl_path)
+    pts = np.asarray(pts, np.float64)
+    faces = np.asarray(faces, np.int32)
+    volume_cm3 = abs(stl_reader.volume_mm3(pts, faces)) / 1000.0
+
+    mesh_mod = getattr(cadmould, "mesh", None)
+    io_mod = getattr(mesh_mod, "io", None) if mesh_mod else None
+    Mesh = getattr(mesh_mod, "Mesh", None) or cadmould.domain.Mesh
+    Mesher = getattr(mesh_mod, "Mesher", None) or cadmould.tools.Mesher
+    CfexWriter = getattr(io_mod, "CfexWriter", None) or cadmould.io.CfexWriter
+
+    sdk_fill_time = None
+    with cadmould.Session.user_based():
+        logger("  cadmould licence session opened (user_based); a failed sign-in prints above")
+        meshed = Mesher(Mesh(pts.ravel(), faces.ravel())).with_surface_triangulation().with_thickness_and_w2w().build()
+        gate = cadmould.tools.suggest_gates(meshed).points[0]
+        suggested = [float(gate.x), float(gate.y), float(gate.z)]
+        cfex_out.parent.mkdir(parents=True, exist_ok=True)
+        CfexWriter().save(meshed, str(cfex_out))
+        n_nodes = int(meshed.node_count())
+        # The SDK's own fill-time estimate is the one to use where it is reachable: it accounts
+        # for wall thickness and the grade's rheology, and a hand-picked "fill it in 1 s" has been
+        # measured 3.5x wrong on a thin part. But the chain is
+        # estimate_fill_time(mesh, FillProfile) <- suggest_fill_profile(mesh, Material, gates)
+        # and `Material` can only be built from a local `.plb` - the cloud catalogue exposes
+        # materials by id, not as a downloadable card. So this runs only when a .plb is supplied
+        # via CADMOULD_MATERIAL_PLB; otherwise the caller falls back to the wall-thickness rule
+        # and says so. Not a bug to fix here - a missing input, named.
+        plb = os.environ.get("CADMOULD_MATERIAL_PLB")
+        if plb and Path(plb).exists():
+            try:
+                material = cadmould.material.io.PlbReader().load(plb)
+                gates_obj = cadmould.tools.suggest_gates(meshed)
+                profile = cadmould.tools.suggest_fill_profile(meshed, material, gates_obj)
+                sdk_fill_time = float(cadmould.tools.estimate_fill_time(meshed, profile))
+                logger(f"  SDK fill-time estimate: {sdk_fill_time:.2f} s (from {Path(plb).name})")
+            # Deliberately broad: the SDK's exception types vary across wheel versions.
+            except Exception as exc:
+                logger(f"  (SDK fill-time estimate failed: {type(exc).__name__}: {exc})")
+        else:
+            logger("  (no CADMOULD_MATERIAL_PLB set - the SDK fill-time estimate needs a local material card)")
+
+    node_coords = T.parse_cfex_nodes(cfex_out)
+    dims = np.ptp(node_coords, axis=0)
+    long_axis = int(np.argmax(dims))
+    logger(
+        f"  meshed {n_nodes} nodes; cfex {len(node_coords)} nodes; volume {volume_cm3:.2f} cm3; "
+        f"long axis {'xyz'[long_axis]} ({dims[long_axis]:.0f} mm)"
+    )
+    return MeshedPart(cfex_out, node_coords, suggested, volume_cm3, long_axis, n_nodes, sdk_fill_time)
+
+
+# ==========================================================================
+# the study
+# ==========================================================================
+class QuotingStudy:
+    """One cloud project per quote; meshes once, uploads once, runs small scored batches."""
+
+    def __init__(
+        self,
+        project_name: str,
+        part: MeshedPart,
+        results_dir: str | Path,
+        *,
+        token: str | None = None,
+        geometry_id: str | None = None,
+        project_id: str | None = None,
+        logger=print,
+    ):
+        self.part = part
+        self.results_dir = Path(results_dir)
+        self.logger = logger
+        self.api = T.PlatformAPI(T.BASE_URL, token or T.access_token(), logger=lambda *_: None)
+        if project_id:
+            self.project_id = project_id
+            logger(f"  reusing cloud project id={project_id}")
+        else:
+            proj = self.api.get_or_create_project(
+                project_name, notes="Quotation study - gating, pressure and process window for a costed offer"
+            )
+            self.project_id = proj["id"]
+            logger(f"  cloud project '{project_name}' id={self.project_id}")
+        self.geometry_id = geometry_id
+        self.material: MaterialResolution | None = None
+
+    def close(self) -> None:
+        self.api.close()
+
+    def note(self, message: str, *, title: str | None = None) -> None:
+        """Write a decision into the cloud project log and echo it locally."""
+        self.logger(f"  note: {message}")
+        self.api.add_note(self.project_id, message, title=title)
+
+    # -- material ----------------------------------------------------------
+    def resolve_material(self, grade: dict) -> MaterialResolution:
+        """Find the house grade in the platform catalogue and read its process + thermal data.
+
+        The catalogue is the authority for melt/mould temperature *and* for the thermal data the
+        cooling-time model needs, so a resolved material removes two guesses at once. Record
+        which catalogue entry was used - house names and catalogue names are not the same thing.
+
+        **A house grade that is not in the catalogue must not abort a quote.** Shops run compounds
+        the catalogue has never heard of, and refusing to quote because a trade name does not
+        match would make this unusable. So the search falls back to the shop's own declared
+        stand-in and then to the family's generic grade, and the substitution is carried through
+        to the quote's assumptions rather than being hidden.
+        """
+        primary = grade.get("catalogue_query") or grade["name"]
+        candidates = [primary]
+        for extra in (grade.get("catalogue_fallback"), f"{grade.get('family', '')} Generic"):
+            if extra and extra not in candidates:
+                candidates.append(extra)
+
+        mat, matched = None, ""
+        for query in candidates:
+            try:
+                mat = self.api.find_material(query)
+                matched = query
+                break
+            except RuntimeError:
+                self.logger(f"  material '{query}' not in the catalogue; trying the next stand-in")
+        if mat is None:
+            raise RuntimeError(
+                f"none of {candidates} is in the material catalogue. Add a reachable "
+                f"'catalogue_fallback' for '{grade['name']}' in shop/materials.md."
+            )
+        substituted = matched != primary
+        ver = self.api.get_material_version(mat["latest_version"]["version_id"])
+        thermal = dict(FAMILY_THERMAL.get(grade.get("family", ""), DEFAULT_THERMAL))
+        got = []
+        for key, src in (
+            ("lambda_W_mK", "lambda_W_mK"),
+            ("cp_J_kgK", "cp_J_kgK"),
+            ("rho_kg_m3", "melt_density_kg_m3"),
+            ("no_flow_K", "no_flow_temperature_K"),
+            ("eject_K", "ejection_temperature_K"),
+        ):
+            if ver.get(src) is not None:
+                thermal[key] = float(ver[src])
+                got.append(key)
+        self.material = MaterialResolution(
+            house_name=grade["name"],
+            catalogue_name=mat.get("trade_name", matched),
+            material_id=mat["material_id"],
+            version_id=mat["latest_version"]["version_id"],
+            melt_K=float(ver["suggested_mass_temp_K"]),
+            wall_K=float(ver["suggested_wall_temp_K"]),
+            thermal=thermal,
+            source="catalogue" if len(got) >= 3 else "family-default",
+            matched_on=matched,
+            substituted=substituted,
+        )
+        self.logger(
+            f"  material '{grade['name']}' -> catalogue '{self.material.catalogue_name}'"
+            f"{' (SUBSTITUTE)' if substituted else ''} "
+            f"melt {self.material.melt_K - 273.15:.0f}C wall {self.material.wall_K - 273.15:.0f}C "
+            f"(thermal data: {'catalogue' if got else 'family default'})"
+        )
+        return self.material
+
+    # -- geometry ----------------------------------------------------------
+    def upload_geometry(self) -> str:
+        if self.geometry_id:
+            return self.geometry_id
+        up = self.api.request_geometry_upload(self.part.cfex_path.name, description="quotation study")
+        self.geometry_id = up["geometry_id"]
+        self.api.put_cfex(up["presigned_put_url"], self.part.cfex_path)
+        self.logger(f"  geometry_id={self.geometry_id}")
+        return self.geometry_id
+
+    def gate_axis_positions(self, gates_mm: list[list[float]]) -> list[float]:
+        """Each gate's position along the part's long axis, normalised to 0..1.
+
+        The weld consolidation works in this space because that is the space the result's weld
+        clusters are reported in - and because the result mesh is re-centred on the origin while
+        the submitted gate coordinates are not, so raw distances between the two are meaningless.
+        """
+        axis = self.part.long_axis
+        coords = self.part.node_coords[:, axis]
+        lo, hi = float(coords.min()), float(coords.max())
+        span = max(hi - lo, 1e-9)
+        return [float((g[axis] - lo) / span) for g in gates_mm]
+
+    # -- running -----------------------------------------------------------
+    def _filling_with_retry(self, cfg: dict, group_id: str, *, retries: int = 4, backoff: float = 2.0) -> dict:
+        """The AI filling call, with the backoff the endpoint needs under any concurrency."""
+        last: Exception | None = None
+        for attempt in range(retries + 1):
+            try:
+                return self.api.run_filling(
+                    geometry_id=self.geometry_id,
+                    material_id=self.material.material_id,
+                    gate_positions_mm=cfg["gates_mm"],
+                    melt_temperature_K=self.material.melt_K,
+                    wall_temperature_K=self.material.wall_K,
+                    flow_rate_cm3_s=cfg["flow_rate_cm3_s"],
+                    estimated_filling_time_s=cfg["fill_time_s"],
+                    model_version=MODEL_VERSION,
+                    num_timesteps=NUM_TIMESTEPS,
+                    htc_W_m2K=HTC_W_M2K,
+                    label=cfg["label"],
+                    project_id=self.project_id,
+                    group_id=group_id,
+                    solver_type="ai",
+                )
+            except httpx.HTTPStatusError as exc:
+                last = exc
+                if exc.response.status_code not in (429, 500, 502, 503, 504):
+                    raise
+            except (httpx.TimeoutException, httpx.TransportError) as exc:
+                last = exc
+            if attempt < retries:
+                time.sleep(backoff * (attempt + 1))
+        raise last  # type: ignore[misc]
+
+    def run_batch(self, group_name: str, configs: list[dict], *, description: str = "") -> list[GateOption]:
+        """Create a cloud group and run its configs (low concurrency - the endpoint sheds load)."""
+        self.upload_geometry()
+        grp = self.api.create_group(self.project_id, group_name, description=description or f"{len(configs)} runs")
+        out_dir = self.results_dir / re.sub(r"[^A-Za-z0-9_-]+", "_", group_name)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        self.logger(f"\n  group '{group_name}' -> {len(configs)} simulations")
+
+        def run_one(cfg: dict) -> GateOption:
+            res = self._filling_with_retry(cfg, grp["id"])
+            sim_id = res["simulation_id"]
+            h5 = out_dir / f"{cfg['label']}__{sim_id[:8]}.h5"
+            self.api.download_to(res["result"]["download"]["url"], h5)
+            a = T.metrics.analyze(h5, cfg["gates_mm"], long_axis=self.part.long_axis)
+            welds = consolidate_welds(a, self.gate_axis_positions(cfg["gates_mm"]), float(a.total_fill_time_s))
+            return GateOption(
+                n_gates=len(cfg["gates_mm"]),
+                gates_mm=cfg["gates_mm"],
+                flow_rate_cm3_s=cfg["flow_rate_cm3_s"],
+                fill_time_s=float(a.total_fill_time_s),
+                max_pressure_bar=float(a.max_pressure_bar),
+                max_shear_1s=float(a.max_shear_rate_1s),
+                fill_pct=float(a.fill_pct),
+                tail_fraction=float(a.tail_fraction),
+                n_welds=len(welds),
+                weld_axis_pos=[round(w.axis_pos, 3) for w in welds],
+                n_interior_welds=sum(1 for w in welds if not w.at_end),
+                n_weld_clusters_raw=int(a.n_welds),
+                short_shot=bool(a.short_shot),
+                simulation_id=sim_id,
+                h5_path=str(h5),
+                label=cfg["label"],
+            )
+
+        results: list[GateOption] = []
+        # max_workers=2: the synchronous filling endpoint sheds load (5xx) above that.
+        with cf.ThreadPoolExecutor(max_workers=min(2, len(configs))) as pool:
+            futures = {pool.submit(run_one, c): c for c in configs}
+            for fut in cf.as_completed(futures):
+                cfg = futures[fut]
+                try:
+                    opt = fut.result()
+                # Deliberately broad: one dead run must not kill the batch.
+                except Exception as exc:
+                    self.logger(f"  {cfg['label']:18s} FAILED: {type(exc).__name__}: {exc}")
+                    continue
+                results.append(opt)
+                self.logger(opt.row())
+        results.sort(key=lambda o: (o.n_gates, o.flow_rate_cm3_s))
+        return results
+
+    # -- the two batches a quote actually needs ----------------------------
+    def _config(self, gates: list[list[float]], flow: float, label: str) -> dict:
+        return {
+            "gates_mm": gates,
+            "flow_rate_cm3_s": float(flow),
+            "fill_time_s": round(self.part.volume_cm3 / max(flow, 1e-6), 3),
+            "label": label,
+        }
+
+    def nominal_flow_cm3_s(self, nominal_wall_mm: float | None = None) -> float:
+        """Volume / target fill time, with the target from the SDK wherever the wheel provides it.
+
+        The SDK's ``estimate_fill_time`` accounts for wall thickness and the grade's rheology, so
+        it is always preferred. The fallback scales with wall thickness rather than being a
+        constant, because a fixed "fill it in 1 s" has been measured 3.5x wrong on a thin part -
+        and since the flow rate sets both the fill time and the pressure, that error propagates
+        into the cycle, the press and the price.
+        """
+        target = self.part.sdk_fill_time_s
+        if not target or target <= 0:
+            target = max(0.3, 0.9 * float(nominal_wall_mm or 1.0))
+            self.logger(f"  (no SDK fill-time estimate; falling back to {target:.2f} s from wall thickness)")
+        return float(self.part.volume_cm3 / target)
+
+    def gate_count_batch(self, counts: list[int], flow: float) -> list[GateOption]:
+        """The decision that costs hot-runner nozzles: how many gates per cavity."""
+        geo = self.part.harness_geometry()
+        configs = []
+        for n in counts:
+            fracs = [(i + 0.5) / n for i in range(n)]
+            configs.append(self._config(T.gate_line(geo, fracs), flow, f"{n}gate"))
+        return self.run_batch(
+            "Q1 - gate count",
+            configs,
+            description=(
+                "Gate count at a fixed nominal process. Each extra gate lowers filling pressure "
+                "(possibly a smaller press) and adds a hot-runner nozzle per cavity plus a weld "
+                "line. The quote takes the cheapest option that still fills."
+            ),
+        )
+
+    def process_batch(self, gates: list[list[float]], flows: list[float]) -> list[GateOption]:
+        """The flow-rate sweep that sets the fill part of the cycle and the shear ceiling."""
+        configs = [self._config(gates, f, f"flow_{f:.0f}") for f in flows]
+        return self.run_batch(
+            "Q2 - process window",
+            configs,
+            description=(
+                "Flow-rate sweep at the chosen gating. Fixes the fill time used in the cycle-time "
+                "estimate and shows where shear rate, not pressure, starts to limit the process."
+            ),
+        )
+
+
+# ==========================================================================
+# offline fallback - so the flow is demonstrable without cloud access
+# ==========================================================================
+def estimate_options(
+    volume_cm3: float,
+    nominal_wall_mm: float,
+    flow_length_mm: float,
+    counts: list[int],
+    grade: dict,
+    *,
+    fill_time_s: float = 1.0,
+) -> list[GateOption]:
+    """Rule-of-thumb stand-in for the gate-count batch when there is no cloud access.
+
+    Pressure scales super-linearly with flow length, and flow length halves roughly with each
+    doubling of gate count. This reproduces the *shape* of the trade-off well enough to exercise
+    the costing - it is **not** a substitute for the simulation, and every quote built on it is
+    marked ``source="estimated"`` all the way through to ``quote.json``.
+    """
+    p_ref = float(grade.get("clamp_pressure_bar", 400))
+    out = []
+    for n in counts:
+        length = flow_length_mm / max(n, 1)
+        # p ~ (L/t)^1.3, normalised so that L/t = 100 at one gate lands on the family reference.
+        ratio = (length / max(nominal_wall_mm, 1e-6)) / 100.0
+        pressure = p_ref * (max(ratio, 1e-3) ** 1.3)
+        out.append(
+            GateOption(
+                n_gates=n,
+                gates_mm=[],
+                flow_rate_cm3_s=volume_cm3 / max(fill_time_s, 1e-6),
+                fill_time_s=fill_time_s,
+                max_pressure_bar=pressure,
+                max_shear_1s=float("nan"),
+                fill_pct=100.0,
+                tail_fraction=0.10,
+                # A single gate welds only where the front wraps back on itself: the two ends.
+                # Every additional gate adds one interior weld at the midpoint of the pair.
+                n_welds=(n - 1) + 2,
+                n_interior_welds=n - 1,
+                source="estimated",
+                label=f"{n}gate (est.)",
+            )
+        )
+    return out

simcon_toolkit/_kit/templates/quoting/quoting/toolkit.py

@@ -0,0 +1,50 @@
+"""The cloud client and result metrics a quote needs, from the kit's shared packages.
+
+The kit ships a worked REST client (``cadmould_cloud``: Auth0 PKCE login plus
+``PlatformAPI``) and a validated result analyser (``cadmould_scoring.metrics``: pressure,
+fill evenness, weld-line detection). A quote needs exactly those, so this module re-exports
+them rather than forking 400 lines that would then drift.
+
+``PlatformAPI.add_note`` is the project decision log: six months on, the estimator can see
+*why* the tool was quoted with two gates. The local log (``cache/<key>/decisions.md``)
+stays the primary record and the project note is the shared copy.
+
+``prepare_geometry`` and the gate helpers come from ``cadmould_geometry.mesh``, which
+imports the licensed ``cadmould`` wheel only inside the functions that mesh - so the
+offline half of a quote (geometry, costing) runs on a machine with no licence.
+"""
+
+from __future__ import annotations
+
+import os
+
+from cadmould_cloud import auth as cloud_auth
+from cadmould_cloud.client import PlatformAPI
+from cadmould_geometry.mesh import (
+    Geometry as HarnessGeometry,
+    gate_line,
+    parse_cfex_nodes,
+    snap,
+)
+from cadmould_scoring import metrics
+
+BASE_URL = os.environ.get("CLOUD_BASE_URL", "https://api.simcon.ai/api/v1")
+
+
+def access_token() -> str:
+    """Bearer token for the REST API - env var first, then the PKCE browser login."""
+    token = os.environ.get("CLOUD_SOLVER_TOKEN")
+    return token if token else cloud_auth.get_access_token()
+
+
+__all__ = [
+    "BASE_URL",
+    "HarnessGeometry",
+    "PlatformAPI",
+    "access_token",
+    "cloud_auth",
+    "gate_line",
+    "metrics",
+    "parse_cfex_nodes",
+    "snap",
+]

simcon_toolkit/_kit/templates/quoting/shop/README.md

@@ -0,0 +1,43 @@
+# `shop/` — the agent's own context
+
+Everything the quoting agent knows about **this shop**: what we do, what we run it on, what we
+buy, what we charge, and what we got wrong last time. The agent reads **all** of it before it
+quotes anything, and it **writes back** to [`lessons.md`](lessons.md) after every review.
+
+Replace the contents with your own shop. The example content is a fictional German
+moldmaker + molder (`Feldmann Formenbau & Spritzguss GmbH`) — realistic in shape, invented in
+numbers.
+
+| File | Holds | Who edits it |
+|---|---|---|
+| [`shop-profile.md`](shop-profile.md) | what we sell, what we do in-house, how we quote | you |
+| [`machines.md`](machines.md) | the press list — clamp, shot, tie-bars, hourly rate | you |
+| [`materials.md`](materials.md) | house grades, prices, and the **material bias** | you |
+| [`tooling.md`](tooling.md) | the mold cost model — bases, cavities, slides, hot runner | you |
+| [`commercial.md`](commercial.md) | labour, overhead, scrap, packaging, margin, terms | you |
+| [`lessons.md`](lessons.md) | **corrections from real quotes + the calibration numbers** | **the agent** |
+
+## The two layers in each file
+
+Each file is **prose for the agent** plus one fenced block of **JSON for the code**:
+
+````markdown
+```json machines
+{ "machines": [ … ] }
+```
+````
+
+The prose is where judgement lives ("we don't take Class-A cosmetic work"); the JSON block is
+what [`quoting/shop.py`](../quoting/shop.py) parses so the cost model computes with the same
+numbers you read. Keep the two consistent — if you change a rate in the prose, change it in the
+block. The block name is the word after `json` on the fence; nothing else in the file is parsed.
+
+## How this stays true over time
+
+The last stage of every quote is a review: the agent shows what it decided, the user corrects
+it, and the agent writes each correction into `lessons.md` — the **reason** as prose, the
+**number** into the `calibration` block. `quoting/costing.py` reads that block on the next
+quote, so a correction changes the next answer instead of being forgotten. That is the whole
+self-improving loop; there is nothing else to it.
+
+Expect the first handful of quotes to be mostly learning. That is the intended use.