processforge 0.3.21__tar.gz → 0.3.23__tar.gz

{processforge-0.3.21/src/processforge.egg-info → processforge-0.3.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.21
+Version: 0.3.23
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -31,6 +31,7 @@ Requires-Dist: zarr>=3.0
 Requires-Dist: pint<1.0,>=0.24
 Requires-Dist: coolprop>=7.2.0
 Requires-Dist: typer>=0.12
+Requires-Dist: arrow>=1.3
 Provides-Extra: api
 Requires-Dist: fastapi>=0.110; extra == "api"
 Requires-Dist: uvicorn>=0.29; extra == "api"

{processforge-0.3.21 → processforge-0.3.23}/flowsheets/hydraulic-chain.json

@@ -105,7 +105,7 @@
   "simulation": {
     "mode": "steady",
     "t0": 0.0,
-    "tf": 20.0,
+    "tf": 25.0,
     "dt": 1.0
   }
 }

{processforge-0.3.21 → processforge-0.3.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.21"
+version = "0.3.23"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -37,6 +37,7 @@ dependencies = [
     "pint>=0.24,<1.0",
     "coolprop>=7.2.0",
     "typer>=0.12",
+    "arrow>=1.3",
 ]
 
 [project.optional-dependencies]

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/__init__.py

@@ -30,7 +30,7 @@ from .units.flash import Flash
 from .units.heater import Heater
 from .eo import EOFlowsheet, EOSolver
 
-__version__ = "0.3.21"
+__version__ = "0.3.23"
 
 __all__ = [
     "Flowsheet",

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/cli/apply.py

@@ -133,11 +133,14 @@ def apply(
             return
         stream_drifts = [d for d in drifted if d.startswith("streams.")]
         unit_drifts = [d for d in drifted if d.startswith("units.")]
+        other_drifts = [d for d in drifted if not d.startswith(("streams.", "units."))]
         logger.warning("Drift detected:")
         if stream_drifts:
             logger.warning(f"  Stream drift : {stream_drifts}")
         if unit_drifts:
             logger.warning(f"  Unit drift   : {unit_drifts}")
+        if other_drifts:
+            logger.warning(f"  Config drift : {other_drifts}")
 
     # Build flowsheet; attach saved state for warm-start unless topology changed
     fs = EOFlowsheet(config, backend=backend)

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/cli/common.py

@@ -145,6 +145,13 @@ def load_state_manager(outputs_dir: str, base_name: str) -> tuple[ProcessStateAr
 # Provider checking
 # ---------------------------------------------------------------------------
 
+# Retry/poll settings for containerized provider health checks. A container
+# spun up by ``pf init`` may take a few seconds to become ready; poll rather
+# than failing immediately so ``pf run`` waits for readiness with visible text.
+HEALTH_MAX_ATTEMPTS = 6
+HEALTH_RETRY_DELAY = 5  # seconds between attempts
+
+
 def is_local_provider_url(url: str | None) -> bool:
     """Return True if *url* points at a locally-managed provider.
 
@@ -184,6 +191,85 @@ def _ping_provider_health(url: str, timeout: int = 5) -> tuple[bool, "dict | str
         return False, str(exc)
 
 
+def _check_container_provider(
+    name: str,
+    ptype: str,
+    url: str,
+    flowsheet_path: str,
+    *,
+    fail_fast: bool,
+    errors: list[str],
+) -> None:
+    """Probe a containerized provider's ``/health`` endpoint with a retry/poll.
+
+    Polls up to ``HEALTH_MAX_ATTEMPTS`` times (``HEALTH_RETRY_DELAY`` apart) so a
+    container that is still booting after ``pf init`` gets a chance to become
+    ready before we give up. Logs a visible ``[OK]``/``[ERR]`` line (matching the
+    ``pf plan`` convention) so ``pf run`` never silently waits.
+    """
+    import time
+
+    ok, info = False, "not probed"
+    for attempt in range(1, HEALTH_MAX_ATTEMPTS + 1):
+        ok, info = _ping_provider_health(url, timeout=5)
+        if ok:
+            break
+        if attempt < HEALTH_MAX_ATTEMPTS:
+            logger.info(
+                f"  Waiting for '{name}' container to become healthy at {url}… "
+                f"(attempt {attempt}/{HEALTH_MAX_ATTEMPTS})"
+            )
+            time.sleep(HEALTH_RETRY_DELAY)
+
+    if ok:
+        payload = info if isinstance(info, dict) else {}
+        status = payload.get("status", "?")
+        provider_type = payload.get("provider_type", "?")
+        logger.info(
+            f"  [OK] {name} [{ptype}] {url} — status={status} provider_type={provider_type}"
+        )
+        return
+
+    msg = (
+        f"  [ERR] {name} [{ptype}] {url} — unreachable after "
+        f"{HEALTH_MAX_ATTEMPTS} attempt(s): {info}. "
+        f"Run: pf init {flowsheet_path}"
+    )
+    logger.error(msg)
+    if fail_fast:
+        raise SystemExit(1)
+    errors.append(f"Provider '{name}' unreachable at {url}: {info}")
+
+
+def _check_pip_provider(
+    name: str,
+    ptype: str,
+    flowsheet_path: str,
+    *,
+    fail_fast: bool,
+    errors: list[str],
+) -> None:
+    """Verify a pip-installable provider's module is importable."""
+    from ..providers.registry import _PROVIDER_CATALOG
+
+    catalog = _PROVIDER_CATALOG.get(ptype, {})
+    module = catalog.get("module", "")
+    try:
+        importlib.util.find_spec(module)
+        logger.info(f"  [OK] {name} [{ptype}] (pip — importable)")
+    except (ModuleNotFoundError, ValueError):
+        dep = catalog.get("optional_dep")
+        hint = f"pip install 'processforge[{dep}]'" if dep else "built-in"
+        msg = (
+            f"  [WARN] {name} [{ptype}] — not installed. "
+            f"Run: pf init {flowsheet_path}  (install with: {hint})"
+        )
+        logger.warning(msg)
+        if fail_fast:
+            raise SystemExit(1)
+        errors.append(f"Provider '{name}' not installed ({hint})")
+
+
 def check_providers(
     config: dict,
     flowsheet_path: str,
@@ -193,56 +279,41 @@ def check_providers(
 ) -> None:
     """Verify all declared providers are reachable or importable.
 
+    For containerized providers this pings the container's ``/health`` endpoint
+    (with a short retry/poll so a still-booting container can become ready) and
+    logs a visible ``[OK]``/``[ERR]`` line — so ``pf run`` shows a clear health
+    check instead of silently waiting. Pip-installable providers are checked for
+    importability and reported the same way.
+
     Parameters
     ----------
     fail_fast:
         If ``True`` (default), raise ``SystemExit`` on the first failure.
         If ``False``, accumulate errors and raise once at the end.
     verbose:
-        If ``True``, log per-provider success messages.
+        Accepted for compatibility; the health check is always logged.
     """
-    from ..providers.registry import is_containerized, _PROVIDER_CATALOG
+    from ..providers.registry import is_containerized
 
     providers = config.get("providers", {})
     errors: list[str] = []
 
+    if providers:
+        logger.info("=== Provider / Container Health ===")
+
     for name, cfg in providers.items():
         ptype = cfg.get("type", "")
         if is_containerized(ptype):
             url = _resolve_provider_url(cfg, ptype)
-            try:
-                urllib.request.urlopen(f"{url}/health", timeout=5)
-                if verbose:
-                    logger.info(f"Provider '{name}' — reachable at {url}")
-            except (urllib.error.URLError, OSError, TimeoutError) as exc:
-                msg = (
-                    f"Provider '{name}' unreachable at {url}. "
-                    f"Run: pf init {flowsheet_path}"
-                )
-                if fail_fast:
-                    logger.error(msg)
-                    raise SystemExit(1)
-                logger.error(msg)
-                errors.append(msg)
+            _check_container_provider(
+                name, ptype, url, flowsheet_path,
+                fail_fast=fail_fast, errors=errors,
+            )
         else:
-            catalog = _PROVIDER_CATALOG.get(ptype, {})
-            module = catalog.get("module", "")
-            try:
-                importlib.util.find_spec(module)
-                if verbose:
-                    logger.info(f"Provider '{name}' — importable (pip)")
-            except (ModuleNotFoundError, ValueError):
-                dep = catalog.get("optional_dep")
-                hint = f"pip install 'processforge[{dep}]'" if dep else "built-in"
-                msg = (
-                    f"Provider '{name}' not installed. "
-                    f"Run: pf init {flowsheet_path}  (install with: {hint})"
-                )
-                if fail_fast:
-                    logger.error(msg)
-                    raise SystemExit(1)
-                logger.error(msg)
-                errors.append(msg)
+            _check_pip_provider(
+                name, ptype, flowsheet_path,
+                fail_fast=fail_fast, errors=errors,
+            )
 
     if errors:
         raise SystemExit(1)

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/cli/run.py

@@ -19,6 +19,7 @@ from .common import (
     output_root,
     require_existing_file,
     validate_runtime_flowsheet,
+    _resolve_provider_url,
 )
 
 
@@ -38,6 +39,39 @@ def _run_id() -> str:
     return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "_" + os.urandom(3).hex()
 
 
+def _log_active_providers(config: dict) -> None:
+    """Log a one-line summary of the provider(s) a run will dispatch to.
+
+    Highlights containerized providers (which do their real work inside a Docker
+    container and can take a while) so the user sees what is running instead of
+    a silent wait. Pip-installable providers are mentioned for completeness.
+    """
+    from ..providers.registry import is_containerized
+
+    providers = config.get("providers", {})
+    if not providers:
+        return
+
+    containers = []
+    pips = []
+    for name, cfg in providers.items():
+        ptype = cfg.get("type", "")
+        if is_containerized(ptype):
+            url = _resolve_provider_url(cfg, ptype)
+            containers.append(f"{name} [{ptype}] @ {url}")
+        else:
+            pips.append(f"{name} [{ptype}]")
+
+    if containers:
+        logger.info("=== Active providers (containerized) ===")
+        for entry in containers:
+            logger.info(f"  → {entry}")
+    if pips:
+        logger.info("=== Active providers (local) ===")
+        for entry in pips:
+            logger.info(f"  → {entry}")
+
+
 def run(
     flowsheet: str = typer.Argument(help="Path to the flowsheet JSON file"),
     export_images: bool = typer.Option(
@@ -53,6 +87,10 @@ def run(
     # Check provider availability (assumes any containers are already running)
     check_providers(config, flowsheet)
 
+    # Surface which containerized provider(s) this run will dispatch to, so the
+    # command line isn't silent while the container does the heavy compute.
+    _log_active_providers(config)
+
     base_name = flowsheet_basename(flowsheet)
     outputs_dir = output_root()
 

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/cli/runs.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 
+import arrow
 import typer
 from loguru import logger
 
@@ -12,20 +13,16 @@ from .common import flowsheet_basename, output_root
 from ..persistence.archive import ProcessStateArchive
 
 
-def _summary_for(manifest) -> str:
-    """One-line summary of a run's primary unit fields (e.g. keff)."""
-    parts = []
-    for unit_name, out in manifest.units.items():
-        for f in out.fields:
-            val = f.quantity.value
-            unit = f.quantity.unit or ""
-            parts.append(f"{unit_name}.{f.name}={val}{(' ' + unit) if unit else ''}")
-    return "  ".join(parts) if parts else "-"
+def _humanize_timestamp(ts: str) -> str:
+    """Render a stored timestamp as a human-readable relative string.
 
-
-def _zarr_status(archive_path: str, run_id: str) -> str:
-    zarr_path = os.path.join(archive_path, "results", run_id, "results.zarr")
-    return "✓" if os.path.exists(zarr_path) else "✗"
+    Falls back to the raw string for values that aren't parseable ISO-8601
+    (e.g. ``20260101T000000Z`` used in some test fixtures).
+    """
+    try:
+        return arrow.get(ts).humanize()
+    except (arrow.parser.ParserError, ValueError, TypeError):
+        return ts
 
 
 def runs(
@@ -73,10 +70,7 @@ def runs(
         typer.echo(f"No runs found for '{flowsheet}'.")
         return
 
-    header = (
-        f"{'RUN ID':<28} {'TIMESTAMP':<22} {'MODE':<8} "
-        f"{'ZARR':<5} {'LATEST':<6} SUMMARY"
-    )
+    header = f"{'RUN ID':<28} {'TIMESTAMP':<22} LATEST"
     typer.echo(header)
     typer.echo("-" * len(header))
     for rid in run_ids:
@@ -85,12 +79,10 @@ def runs(
             continue
         marker = "*" if rid == latest_id else " "
         typer.echo(
-            f"{rid:<28} {manifest.timestamp:<22} {manifest.mode:<8} "
-            f"{_zarr_status(archive_path, rid):<5} {marker:<6} "
-            f"{_summary_for(manifest)}"
+            f"{rid:<28} {_humanize_timestamp(manifest.timestamp):<22} {marker}"
         )
     typer.echo("")
     typer.echo(
-        "Zarr: ✓ present on disk, ✗ deleted/missing. '*' marks the latest run. "
+        "'*' marks the latest run. "
         "'pf runs <flowsheet> <run_id>' prints the full manifest."
     )

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/output_collector.py

@@ -14,8 +14,10 @@ canonical, unit-aware record persisted by :class:`ProcessStateArchive`:
 """
 from __future__ import annotations
 
+from datetime import datetime, timezone
 from typing import Optional
 
+import arrow
 from loguru import logger
 
 from .types import (
@@ -75,6 +77,20 @@ def collect_stream_outputs(provider, stream_results: dict) -> dict[str, StreamOu
     return out
 
 
+def _timestamp_from_run_id(run_id: str) -> str:
+    """Derive an ISO-8601 timestamp from a run_id's compact UTC prefix.
+
+    Run ids are ``<YYYYMMDDTHHMMSSZ>_<suffix>`` (see ``pf run`` / ``pf apply``),
+    so the start time is recoverable from the id itself. Falls back to the
+    current UTC time for ids that don't follow that convention.
+    """
+    prefix = run_id.split("_", 1)[0]
+    try:
+        return arrow.get(prefix).isoformat()
+    except (arrow.parser.ParserError, ValueError):
+        return datetime.now(timezone.utc).isoformat()
+
+
 def build_run_manifest(
     *,
     run_id: str,
@@ -91,6 +107,7 @@ def build_run_manifest(
         run_id=run_id,
         mode=mode,
         flowsheet=flowsheet_name,
+        timestamp=_timestamp_from_run_id(run_id),
         units=dict(engine_outputs),
         streams=streams,
         provenance=provenance or {},

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/providers/container_client.py

@@ -177,6 +177,15 @@ class ContainerProviderClient(AbstractProvider):
             else {"type": unit_config.provider or self._ptype, "url": self._url}
         )
 
+        # Fall back to context set via set_run_context() (the CLI propagates the
+        # shared run_id/flowsheet_hash there). SolverUnit calls run_simulation()
+        # without these arguments, so without the fallback the container receives
+        # null and artifacts get uploaded under the wrong key.
+        if run_id is None:
+            run_id = self._run_id or None
+        if flowsheet_hash is None:
+            flowsheet_hash = self._flowsheet_hash or None
+
         body = {
             "unit_config": self._serialize_unit_config(unit_config),
             "materials": self._serialize_materials(self._materials),
@@ -190,6 +199,10 @@ class ContainerProviderClient(AbstractProvider):
             f"ContainerProviderClient: POST {self._url}/run "
             f"sim_type='{unit_config.sim_type}' run_id='{run_id}'"
         )
+        logger.info(
+            f"Waiting for '{self._ptype}' container at {self._url} to finish "
+            f"simulation — this may take a while…"
+        )
 
         payload = json.dumps(body).encode()
         req = urllib.request.Request(

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/providers/coolprop_provider.py

@@ -56,11 +56,20 @@ class CoolPropProvider(AbstractProvider):
                 logger.warning(f"Component '{comp}' not found in CoolProp. Cp contribution is 0.")
 
         Ks = {}
+        from CoolProp.CoolProp import AbstractState
+
         for comp in z.keys():
             try:
-                fugL = self.CP.PropsSI("fugL", "T", T, "P", P, comp)
-                fugV = self.CP.PropsSI("fugV", "T", T, "P", P, comp)
-                Ks[comp] = fugL / fugV if fugV != 0 else 1.0
+                st = AbstractState("PR", comp)
+                st.specify_phase(self.CP.iphase_liquid)
+                st.update(self.CP.PT_INPUTS, P, T)
+                phi_L = st.fugacity_coefficient(0)
+                st.unspecify_phase()
+                st.specify_phase(self.CP.iphase_gas)
+                st.update(self.CP.PT_INPUTS, P, T)
+                phi_V = st.fugacity_coefficient(0)
+                st.unspecify_phase()
+                Ks[comp] = phi_L / phi_V if phi_V != 0 else 1.0
             except Exception:
                 logger.warning(f"Could not calculate K-value for '{comp}'. Using fallback K=1.0.")
                 Ks[comp] = 1.0

{processforge-0.3.21 → processforge-0.3.23}/src/processforge/state.py

@@ -226,46 +226,80 @@ class StateManager:
     # Drift & structural diff
     # ------------------------------------------------------------------
 
+    # Keys treated as structural (handled by detect_structural_diff / cold
+    # start) rather than as drifted solve parameters.
+    _STRUCTURAL_UNIT_KEYS = {"type", "in", "out", "out_vap", "out_liq", "provider"}
+
+    # Top-level sections that never affect the solve and must be ignored when
+    # computing drift (cosmetic metadata, and the runtime-injected source path
+    # which is only present on the live config).
+    _DRIFT_SKIP_TOP_LEVEL = {"metadata", "_config_path"}
+
     def detect_drift(self, current_config: dict, state: SnapshotState | dict) -> list[str]:
         """Return parameter paths that differ between ``current_config`` and saved state.
 
+        Recursively diffs the entire config so any solve-affecting change is
+        detected — streams, units (incl. nested ``solver_config`` /
+        ``geometry_config`` / ``parameters``), materials, material mixes,
+        providers and simulation settings. Structural unit keys (``type``,
+        ``in``, ``out``, ``provider``, …) and the cosmetic ``metadata`` /
+        ``_config_path`` sections are excluded so topology changes remain the
+        job of :meth:`detect_structural_diff` / cold start.
+
         Paths look like ``"streams.feed.T"``, ``"units.pump_1.delta_p"``,
-        or ``"units.pump_1.parameters.X"``.
+        ``"units.openmc_solver.solver_config.batches"`` or
+        ``"materials.salt.density"``.
         """
         old_config = state.config if isinstance(state, SnapshotState) else state["config"]
         drifted: list[str] = []
 
-        for s_name, s_data in current_config.get("streams", {}).items():
-            old_s = old_config.get("streams", {}).get(s_name, {})
-            for param in ("T", "P", "flowrate"):
-                if s_data.get(param) != old_s.get(param):
-                    drifted.append(f"streams.{s_name}.{param}")
-
-            cur_z = s_data.get("z", {})
-            old_z = old_s.get("z", {})
-            for comp in cur_z:
-                if cur_z.get(comp) != old_z.get(comp):
-                    drifted.append(f"streams.{s_name}.z.{comp}")
+        for section in set(old_config) | set(current_config):
+            if section in self._DRIFT_SKIP_TOP_LEVEL:
+                continue
+            old_section = old_config.get(section)
+            new_section = current_config.get(section)
+
+            if section == "units":
+                # Diff each unit subtree, skipping structural keys.
+                old_units = old_section or {}
+                new_units = new_section or {}
+                for u_name in set(old_units) | set(new_units):
+                    drifted.extend(
+                        self._recursive_diff(
+                            old_units.get(u_name, {}),
+                            new_units.get(u_name, {}),
+                            prefix=f"units.{u_name}.",
+                            skip=self._STRUCTURAL_UNIT_KEYS,
+                        )
+                    )
+            else:
+                drifted.extend(
+                    self._recursive_diff(old_section, new_section, prefix=f"{section}.", skip=set())
+                )
 
-        _SKIP_KEYS = {"type", "in", "out", "out_vap", "out_liq", "provider", "parameters"}
+        return drifted
 
-        for u_name, u_cfg in current_config.get("units", {}).items():
-            old_u = old_config.get("units", {}).get(u_name, {})
+    @staticmethod
+    def _recursive_diff(old: object, new: object, prefix: str, skip: set[str]) -> list[str]:
+        """Recursively collect changed leaf paths between two (sub)configs."""
+        changes: list[str] = []
 
-            # Top-level scalar keys (mirrors detect_structural_diff comparison)
-            all_keys = set(u_cfg) | set(old_u)
-            for k in all_keys - _SKIP_KEYS:
-                if u_cfg.get(k) != old_u.get(k):
-                    drifted.append(f"units.{u_name}.{k}")
+        if isinstance(old, dict) and isinstance(new, dict):
+            for k in (set(old) | set(new)) - skip:
+                changes.extend(
+                    StateManager._recursive_diff(old.get(k), new.get(k), f"{prefix}{k}.", skip)
+                )
+            return changes
 
-            # Nested "parameters" dict
-            cur_params = u_cfg.get("parameters", {})
-            old_params = old_u.get("parameters", {})
-            for pk in set(cur_params) | set(old_params):
-                if cur_params.get(pk) != old_params.get(pk):
-                    drifted.append(f"units.{u_name}.parameters.{pk}")
+        if isinstance(old, list) and isinstance(new, list):
+            if old != new:
+                changes.append(prefix.rstrip("."))
+            return changes
 
-        return drifted
+        # Leaf / type-mismatch comparison.
+        if old != new:
+            changes.append(prefix.rstrip("."))
+        return changes
 
     def detect_structural_diff(self, current_config: dict, state: SnapshotState | dict) -> dict:
         """Compare unit topology between ``current_config`` and saved state.

{processforge-0.3.21 → processforge-0.3.23/src/processforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.21
+Version: 0.3.23
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -31,6 +31,7 @@ Requires-Dist: zarr>=3.0
 Requires-Dist: pint<1.0,>=0.24
 Requires-Dist: coolprop>=7.2.0
 Requires-Dist: typer>=0.12
+Requires-Dist: arrow>=1.3
 Provides-Extra: api
 Requires-Dist: fastapi>=0.110; extra == "api"
 Requires-Dist: uvicorn>=0.29; extra == "api"

{processforge-0.3.21 → processforge-0.3.23}/src/processforge.egg-info/requires.txt

@@ -10,6 +10,7 @@ zarr>=3.0
 pint<1.0,>=0.24
 coolprop>=7.2.0
 typer>=0.12
+arrow>=1.3
 
 [api]
 fastapi>=0.110

{processforge-0.3.21 → processforge-0.3.23}/tests/test_cli.py

@@ -487,6 +487,59 @@ class TestCmdPlan:
         assert any("[ERR] openmc" in m and "unreachable" in m for m in log_output)
 
 
+class TestCheckProviders:
+    """Health-check + retry/poll behavior used by ``pf run``/``pf apply``."""
+
+    def _config(self, **providers):
+        return {"providers": providers}
+
+    def test_container_health_ok_logs_ok(self, log_output):
+        import processforge.cli.common as common_mod
+        from processforge.cli.common import check_providers
+
+        health = {"status": "ready", "provider_type": "openmc"}
+        with patch.object(
+            common_mod, "_ping_provider_health", return_value=(True, health)
+        ), patch.object(common_mod, "_resolve_provider_url", return_value="http://localhost:9001"):
+            check_providers(self._config(openmc={"type": "openmc"}), "fs.json")
+
+        assert any("=== Provider / Container Health ===" in m for m in log_output)
+        assert any("[OK] openmc" in m and "status=ready" in m for m in log_output)
+        assert not any("Waiting for" in m for m in log_output)
+
+    def test_container_health_retries_then_fails(self, log_output):
+        import processforge.cli.common as common_mod
+        from processforge.cli.common import check_providers
+
+        with patch.object(
+            common_mod, "_ping_provider_health", return_value=(False, "Connection refused")
+        ), patch.object(common_mod, "_resolve_provider_url", return_value="http://localhost:9001"), \
+                patch.object(common_mod, "HEALTH_MAX_ATTEMPTS", 3), \
+                patch.object(common_mod, "HEALTH_RETRY_DELAY", 0), \
+                patch("time.sleep", lambda *_: None), \
+                pytest.raises(SystemExit) as exc_info:
+            check_providers(self._config(openmc={"type": "openmc"}), "fs.json")
+
+        assert exc_info.value.code == 1
+        # Two "Waiting for …" poll messages (attempts 1 and 2 of 3) before failure.
+        wait_msgs = [m for m in log_output if "Waiting for" in m and "openmc" in m]
+        assert len(wait_msgs) == 2
+        assert any("[ERR] openmc" in m and "unreachable after 3" in m for m in log_output)
+
+    def test_pip_provider_logs_ok(self, log_output):
+        import processforge.providers.registry as registry_mod
+        from processforge.cli.common import check_providers
+
+        with patch.object(
+            registry_mod, "_PROVIDER_CATALOG",
+            {"coolprop": {"module": "processforge.providers.coolprop_provider",
+                          "optional_dep": None}},
+        ):
+            check_providers(self._config(coolprop={"type": "coolprop"}), "fs.json")
+
+        assert any("[OK] coolprop" in m and "(pip — importable)" in m for m in log_output)
+
+
 class TestCmdApply:
     def _containerized_config(self, flowsheet_path):
         return {