processforge 0.3.25__tar.gz → 0.4.1__tar.gz

{processforge-0.3.25/src/processforge.egg-info → processforge-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.25
+Version: 0.4.1
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -43,9 +43,13 @@ Requires-Dist: pyomo>=6.7; extra == "eo-casadi"
 Requires-Dist: casadi>=3.6; extra == "eo-casadi"
 Provides-Extra: fmu
 Requires-Dist: pythonfmu>=0.6; extra == "fmu"
+Requires-Dist: fmpy>=0.3; extra == "fmu"
 Provides-Extra: modelica
 Requires-Dist: OMPython>=4.0.0; extra == "modelica"
 Requires-Dist: fmpy>=0.3; extra == "modelica"
+Provides-Extra: pathsim
+Requires-Dist: pathsim>=0.9; extra == "pathsim"
+Requires-Dist: fmpy>=0.3; extra == "pathsim"
 Provides-Extra: cantera
 Requires-Dist: cantera>=3.0; extra == "cantera"
 Provides-Extra: coolprop

{processforge-0.3.25 → processforge-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.25"
+version = "0.4.1"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -55,11 +55,16 @@ eo-casadi = [
 ]
 fmu = [
     "pythonfmu>=0.6",
+    "fmpy>=0.3",
 ]
 modelica = [
     "OMPython>=4.0.0",
     "fmpy>=0.3",
 ]
+pathsim = [
+    "pathsim>=0.9",
+    "fmpy>=0.3",
+]
 cantera = [
     "cantera>=3.0",
 ]

{processforge-0.3.25 → processforge-0.4.1}/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.25"
+__version__ = "0.4.1"
 
 __all__ = [
     "Flowsheet",

{processforge-0.3.25 → processforge-0.4.1}/src/processforge/cli/__init__.py

@@ -32,7 +32,7 @@ def register_commands(app: typer.Typer) -> None:
     )(apply)
     app.command(
         "runs",
-        help="List runs for a flowsheet, or show one run's full manifest (pf runs <flowsheet> [<run_id>])",
+        help="List runs for a flowsheet, or inspect one run's Zarr result summary (pf runs <flowsheet> [<run_id>|latest] [--schema])",
     )(runs)
     app.command(
         "plan",

{processforge-0.3.25 → processforge-0.4.1}/src/processforge/cli/apply.py

@@ -6,46 +6,10 @@ import os
 import time
 from typing import Literal
 
-import hashlib
-import json
-import os
 import typer
-from datetime import datetime, timezone
 from loguru import logger
 
-
-def _persist_run(archive, fs, results, run_info, config, base_name, snapshot_id):
-    """Build a standardized RunManifest and persist it to the archive."""
-    run_id = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "_" + os.urandom(3).hex()
-    flowsheet_hash = hashlib.sha256(
-        json.dumps(config, sort_keys=True, default=str).encode("utf-8")
-    ).hexdigest()[:16]
-    manifest = fs.collect_outputs(
-        run_id, config.get("simulation", {}).get("mode", "steady"),
-        base_name, provenance=run_info.model_dump(),
-    )
-    manifest.snapshot_id = snapshot_id
-    stream_results = {k: v for k, v in results.items() if not hasattr(v, "fields")}
-    archive.save_run(manifest, stream_results=stream_results)
-
-    # Always persist a Zarr copy of the standardized outputs (fields + artifacts)
-    # inside the archive, mirroring `pf run`.
-    try:
-        from ..result import relink_latest_results, save_results_zarr
-
-        run_results_dir = os.path.join(archive.path, "results", run_id)
-        save_results_zarr(
-            results,
-            os.path.join(run_results_dir, "results.zarr"),
-            run_info,
-        )
-        relink_latest_results(archive.path, run_id)
-    except Exception as e:
-        logger.warning(f"Failed to write results.zarr: {type(e).__name__}: {e}")
-
-    logger.info(f"Run saved    : {run_id}")
-    return run_id
-
+from .persist import make_run_id, persist_run
 from ..eo import EOFlowsheet
 from ..provenance import build_run_info
 from .common import (
@@ -158,14 +122,15 @@ def apply(
             label="converged state",
         )
         run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
-        saved_run_id = _persist_run(sm, fs, results, run_info, config, base_name, snapshot_id)
+        run_id = make_run_id()
+        persist_run(sm, fs, run_id, results, run_info, config, base_name, snapshot_id)
         logger.info("=== Apply Summary ===")
         logger.info("  Status       : CONVERGED")
         logger.info(f"  Final ||F||  : {fs.solver_stats.get('final_norm', '?'):.3e}")
         logger.info(f"  Iterations   : {fs.solver_stats.get('iterations', '?')}")
         logger.info(f"  Backend      : {display_backend(config, fs.backend)}")
         logger.info(f"  Snapshot ID  : {snapshot_id}")
-        logger.info(f"  Run ID       : {saved_run_id}")
+        logger.info(f"  Run ID       : {run_id}")
         logger.info(f"  Elapsed (s)  : {elapsed:.2f}")
         return
 
@@ -180,25 +145,31 @@ def apply(
         tmp_fs = _EO(config, backend=backend)
         manager = tmp_fs._build()
         try:
-            x_hom, hom_converged, hom_stats = solve_with_homotopy(
-                tmp_fs, manager, solver, state, drifted
-            )
+            homotopy_result = solve_with_homotopy(tmp_fs, manager, solver, state, drifted)
+            if homotopy_result.converged:
+                # Assemble the real (converged) outputs from the homotopy
+                # solution while the providers are still alive. The `results`
+                # from the earlier failed direct solve must NOT be persisted.
+                tmp_fs.assemble_from_solution(
+                    manager, homotopy_result.x_solution, True, homotopy_result.stats
+                )
         finally:
             teardown_providers(tmp_fs._provider_map)
 
-        if hom_converged:
+        if homotopy_result.converged:
             logger.info(
-                f"Homotopy converged: ||F||={hom_stats.get('final_norm', '?'):.3e}, "
-                f"iterations={hom_stats.get('iterations', '?')}"
+                f"Homotopy converged: ||F||={homotopy_result.stats.get('final_norm', '?'):.3e}, "
+                f"iterations={homotopy_result.stats.get('iterations', '?')}"
             )
-            save_snapshot(
-                sm, config, x_hom, fs.var_names,
+            snapshot_id = save_snapshot(
+                sm, config, homotopy_result.x_solution, fs.var_names,
                 metadata=current_metadata,
                 parent_snapshot_id=state.snapshot_id if state is not None and not topology_changed else None,
                 label="homotopy solution",
             )
             run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
-            _persist_run(sm, fs, results, run_info, config, base_name, snapshot_id)
+            run_id = make_run_id()
+            persist_run(sm, tmp_fs, run_id, tmp_fs.results, run_info, config, base_name, snapshot_id)
             logger.info("Homotopy apply succeeded. New snapshot saved.")
             return
 
@@ -210,8 +181,8 @@ def apply(
         breakdown = log_residual_breakdown(fs)
         divergence = build_divergence_report(
             drifted_params=drifted,
-            solver_stats=hom_stats,
-            x_last=x_hom,
+            solver_stats=homotopy_result.stats,
+            x_last=homotopy_result.x_solution,
             var_names=fs.var_names,
             breakdown=breakdown,
         )

processforge-0.4.1/src/processforge/cli/export_fmu.py

@@ -0,0 +1,88 @@
+"""``pf export-fmu`` — export flowsheet as FMI 2.0 co-simulation FMU."""
+
+from __future__ import annotations
+
+import os
+from typing import Literal
+
+import typer
+from loguru import logger
+
+from .common import require_existing_file
+
+
+def export_fmu(
+    flowsheet: str = typer.Argument(help="Path to the flowsheet JSON file"),
+    output_dir: str = typer.Option(
+        "outputs",
+        "--output-dir",
+        "-o",
+        help="Directory for the output FMU (default: outputs/)",
+    ),
+    backend: Literal["scipy", "pyomo", "casadi"] = typer.Option(
+        "scipy",
+        "--backend",
+        help="EO solver backend for steady-state mode (default: scipy)",
+    ),
+    pathsim: bool = typer.Option(
+        False,
+        "--pathsim",
+        help="Also emit the fmu_interface.json manifest and a PathSim wiring example",
+    ),
+) -> None:
+    """Export a flowsheet as an FMI 2.0 co-simulation FMU."""
+    require_existing_file(flowsheet)
+
+    from ..fmu import build_fmu  # local import — pythonfmu is optional
+
+    output_dir = output_dir or "outputs"
+    backend = backend or "scipy"
+
+    try:
+        fmu_path = build_fmu(
+            flowsheet,
+            output_dir=output_dir,
+            backend=backend,
+            write_manifest=pathsim,
+        )
+        logger.info(f"FMU written to: {fmu_path}")
+        if pathsim:
+            base = os.path.splitext(os.path.basename(fmu_path))[0]
+            manifest_path = os.path.join(output_dir, f"{base}_fmu_interface.json")
+            example_path = os.path.join(output_dir, f"{base}_pathsim.py")
+            _write_pathsim_example(example_path, fmu_path, manifest_path)
+            logger.info(f"Manifest written to: {manifest_path}")
+            logger.info(f"PathSim example written to: {example_path}")
+    except Exception as e:
+        logger.error(f"FMU export failed: {type(e).__name__}: {e}")
+        logger.debug("FMU export traceback:", exc_info=True)
+        raise SystemExit(1)
+
+
+def _write_pathsim_example(example_path: str, fmu_path: str, manifest_path: str) -> None:
+    """Write a minimal PathSim wiring example next to the exported FMU."""
+    content = f'''"""Auto-generated PathSim wiring example."""
+import pathsim as ps
+from processforge.pathsim import ProcessForgeFMU
+
+plant = ProcessForgeFMU(
+    fmu_path={fmu_path!r},
+    manifest_path={manifest_path!r},
+)
+
+# Inspect available ports:
+# print(plant.inputs)
+# print(plant.outputs)
+
+# Example: drive an input with a constant setpoint and read an output.
+setpoint = ps.Constant(val=1.0)
+sim = ps.Simulation(
+    blocks=[setpoint, plant],
+    connections=[
+        # ps.Connection(setpoint, plant["<unit>.<input>"]),
+    ],
+)
+sim.run(time_span=(0, 10))
+'''
+    with open(example_path, "w", encoding="utf-8") as f:
+        f.write(content)

processforge-0.4.1/src/processforge/cli/persist.py

@@ -0,0 +1,99 @@
+"""Shared run-persistence helpers for the ``pf run`` / ``pf apply`` CLIs.
+
+Both commands build a :class:`~processforge.types.RunManifest`, save it to the
+:class:`~processforge.persistence.archive.ProcessStateArchive`, and write a Zarr
+copy of the standardized outputs. That logic was previously duplicated (with
+slightly different bugs in each copy); it now lives here in one place.
+"""
+
+from __future__ import annotations
+
+import datetime
+import hashlib
+import json
+import os
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from ..persistence.archive import ProcessStateArchive
+    from ..types import RunInfo
+
+_RUN_ID_TS_FMT = "%Y%m%dT%H%M%SZ"
+
+
+def make_run_id() -> str:
+    """Build a unique, sortable run id: ``<UTC timestamp>_<6 hex bytes>``."""
+    return (
+        datetime.datetime.now(datetime.timezone.utc).strftime(_RUN_ID_TS_FMT)
+        + "_"
+        + os.urandom(3).hex()
+    )
+
+
+def flowsheet_hash(config: dict) -> str:
+    """Short (16-hex) sha256 of a flowsheet config for run/index correlation."""
+    return hashlib.sha256(
+        json.dumps(config, sort_keys=True, default=str).encode("utf-8")
+    ).hexdigest()[:16]
+
+
+def persist_run(
+    archive: "ProcessStateArchive",
+    fs: Any,
+    run_id: str,
+    results: dict,
+    run_info: "RunInfo | dict",
+    config: dict,
+    base_name: str,
+    snapshot_id: str | None = None,
+) -> str:
+    """Persist a run's manifest + Zarr outputs into *archive*.
+
+    Args:
+        archive: The :class:`ProcessStateArchive` for this flowsheet.
+        fs: The flowsheet object that produced *results* (must expose
+            ``collect_outputs``). Either ``EOFlowsheet`` or ``Flowsheet``.
+        run_id: Unique run id (use :func:`make_run_id`).
+        results: The solve's stream/unit result dict (the *converged* one).
+        run_info: Provenance from
+            :func:`processforge.provenance.build_run_info`.
+        config: Validated flowsheet config (for the simulation mode).
+        base_name: Flowsheet basename used for archive paths.
+        snapshot_id: Optional snapshot id to stamp on the manifest (so a run
+            can be linked back to the state it was derived from).
+
+    Returns:
+        The run id that was persisted.
+    """
+    mode = config.get("simulation", {}).get("mode", "steady")
+    run_info_dump = (
+        run_info.model_dump() if hasattr(run_info, "model_dump") else run_info
+    )
+    manifest = fs.collect_outputs(
+        run_id, mode, base_name, provenance=run_info_dump
+    )
+    if snapshot_id is not None:
+        manifest.snapshot_id = snapshot_id
+
+    stream_results = {k: v for k, v in results.items() if not hasattr(v, "fields")}
+    archive.save_run(manifest, stream_results=stream_results)
+
+    # Always persist a Zarr copy of the standardized outputs (fields + artifacts)
+    # inside the archive, mirroring `pf run`.
+    try:
+        from ..result import relink_latest_results, save_results_zarr
+
+        run_results_dir = os.path.join(archive.path, "results", run_id)
+        save_results_zarr(
+            results,
+            os.path.join(run_results_dir, "results.zarr"),
+            run_info,
+        )
+        relink_latest_results(archive.path, run_id)
+    except Exception as e:
+        logger.warning(f"Failed to write results.zarr: {type(e).__name__}: {e}")
+
+    logger.info(f"Run saved    : {run_id}")
+    return run_id

{processforge-0.3.25 → processforge-0.4.1}/src/processforge/cli/run.py

@@ -1,7 +1,6 @@
 """``pf run`` — run a process simulation from a flowsheet JSON file."""
 from __future__ import annotations
 
-import hashlib
 import os
 from datetime import datetime, timezone
 
@@ -21,22 +20,7 @@ from .common import (
     validate_runtime_flowsheet,
     _resolve_provider_url,
 )
-
-
-def _flowsheet_hash(config: dict) -> str:
-    return hashlib.sha256(
-        json_dumps(config).encode("utf-8")
-    ).hexdigest()[:16]
-
-
-def json_dumps(obj) -> str:
-    import json
-
-    return json.dumps(obj, sort_keys=True, default=str)
-
-
-def _run_id() -> str:
-    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "_" + os.urandom(3).hex()
+from .persist import flowsheet_hash, make_run_id, persist_run
 
 
 def _log_active_providers(config: dict) -> None:
@@ -99,8 +83,8 @@ def run(
     is_dynamic = mode == "dynamic"
 
     # Standardized run id, shared with container-side artifact uploads.
-    run_id = _run_id()
-    flowsheet_hash = _flowsheet_hash(config)
+    run_id = make_run_id()
+    flowsheet_hash_value = flowsheet_hash(config)
 
     if is_dynamic:
         # Load .pfarchive snapshot as t=0 if available.
@@ -164,17 +148,12 @@ def run(
     # are keyed by the same run_id/flowsheet_hash as this archive run.
     for provider in getattr(fs, "_provider_map", {}).values():
         if hasattr(provider, "set_run_context"):
-            provider.set_run_context(run_id, flowsheet_hash)
+            provider.set_run_context(run_id, flowsheet_hash_value)
 
     # Build + persist the standardized run manifest.
     archive_path = os.path.join(outputs_dir, f"{base_name}.pfarchive")
     archive = ProcessStateArchive(archive_path)
-    manifest = fs.collect_outputs(run_id, mode, base_name, provenance=run_info.model_dump())
-    stream_results = {
-        k: v for k, v in results.items()
-        if not hasattr(v, "fields")  # exclude EngineOutput objects
-    }
-    archive.save_run(manifest, stream_results=stream_results)
+    persist_run(archive, fs, run_id, results, run_info, config, base_name)
 
     # Persist a StateManager snapshot so `pf plan` (and `pf apply`) can diff
     # against this run as a baseline. Without it, `pf plan` always reports
@@ -191,27 +170,11 @@ def run(
         except Exception as e:
             logger.warning(f"Failed to save state snapshot: {type(e).__name__}: {e}")
 
-    # Always persist a Zarr copy of the standardized outputs (fields + artifacts)
-    # inside the archive. Works for every provider (OpenMC, CoolProp, FESTIM,
-    # Cantera) and for both local and remote docker runs — remote artifacts
-    # reference their S3 remote_uris.
-    try:
-        from ..result import relink_latest_results, save_results_zarr
-
-        run_results_dir = os.path.join(archive.path, "results", run_id)
-        save_results_zarr(
-            results,
-            os.path.join(run_results_dir, "results.zarr"),
-            run_info,
-        )
-        relink_latest_results(archive.path, run_id)
-    except Exception as e:
-        logger.warning(f"Failed to write results.zarr: {type(e).__name__}: {e}")
-
     logger.info(f"Backend      : {display_backend(config, getattr(fs, 'backend', 'dynamic'))}")
     logger.info(f"Run saved    : {os.path.join(archive_path, 'runs', run_id + '.json')}")
 
     # Summarize standardized outputs.
+    manifest = archive.load_run(run_id)
     for unit_name, out in manifest.units.items():
         for f in out.fields:
             logger.info(f"  [{unit_name}] {f.name} = {f.quantity.value} {f.quantity.unit}")

processforge-0.4.1/src/processforge/cli/runs.py

@@ -0,0 +1,201 @@
+"""``pf runs`` — list runs and inspect their Zarr result summaries."""
+
+from __future__ import annotations
+
+import json
+import os
+
+import arrow
+import typer
+from loguru import logger
+
+from .common import flowsheet_basename, output_root
+from ..persistence.archive import ProcessStateArchive
+from ..result import _fmt_scientific, _one_line_summary, summarize_zarr_store
+
+
+def _humanize_timestamp(ts: str) -> str:
+    """Render a stored timestamp as a human-readable relative string.
+
+    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 _zarr_path(archive_path: str, run_id: str) -> str:
+    """Return the per-run Zarr store path."""
+    return os.path.join(archive_path, "results", run_id, "results.zarr")
+
+
+def _artifact_status(artifact: dict) -> str:
+    """Return a short presence marker for an artifact dict."""
+    local_path = artifact.get("local_path")
+    remote_uris = artifact.get("remote_uris") or []
+    if local_path and os.path.exists(local_path):
+        return "local✓"
+    if remote_uris:
+        return "remote-only"
+    return "missing"
+
+
+def _format_run_details(manifest, summary: dict) -> str:
+    """Format a detailed, human-readable result summary for a single run."""
+    lines = [
+        f"Run: {manifest.run_id}",
+        f"Timestamp: {manifest.timestamp}",
+        f"Mode: {summary.get('mode', manifest.mode)}",
+        "",
+        "Results:",
+        "────────",
+    ]
+
+    engine_outputs = summary.get("engine_outputs", {})
+    if engine_outputs:
+        for name, eo in engine_outputs.items():
+            engine = eo.get("engine", "")
+            sim_type = eo.get("sim_type", "")
+            status = eo.get("status", "")
+            lines.append(f"{name} ({engine} / {sim_type}) [{status}]")
+            for fname, fdata in eo.get("fields", {}).items():
+                val = _fmt_scientific(fdata.get("value"))
+                unit = fdata.get("unit", "")
+                std = fdata.get("std_dev")
+                if std is not None:
+                    lines.append(f"  {fname}: {val} ± {_fmt_scientific(std)} {unit}".strip())
+                else:
+                    lines.append(f"  {fname}: {val} {unit}".strip())
+            if eo.get("attrs") and not eo.get("fields"):
+                for k, v in eo["attrs"].items():
+                    if not k.startswith("_") and k not in ("engine", "sim_type", "status"):
+                        lines.append(f"  {k}: {_fmt_scientific(v)}")
+            lines.append("")
+    else:
+        lines.append("  (no solver/engine outputs)")
+        lines.append("")
+
+    streams = summary.get("streams", {})
+    if streams:
+        lines.append("Streams:")
+        all_vars: set[str] = set()
+        for sdata in streams.values():
+            all_vars.update(sdata.get("variables", []))
+        all_vars = sorted(all_vars)
+
+        header_parts = ["stream".ljust(20)] + [v.rjust(14) for v in all_vars]
+        lines.append("  " + " ".join(header_parts))
+        lines.append("  " + "-" * len("  ".join(header_parts)))
+        for sname in sorted(streams):
+            sdata = streams[sname]
+            fields = sdata.get("fields", {})
+            row = [sname.ljust(20)]
+            for var in all_vars:
+                fdata = fields.get(var, {})
+                val = fdata.get("value")
+                row.append(_fmt_scientific(val).rjust(14))
+            lines.append("  " + " ".join(row))
+        lines.append("")
+
+    artifacts = summary.get("artifacts", [])
+    if artifacts:
+        lines.append("Artifacts:")
+        for art in artifacts:
+            name = art.get("name", "unknown")
+            kind = art.get("kind", "")
+            status = _artifact_status(art)
+            loc = art.get("local_path") or (art.get("remote_uris") or ["no location"])[0]
+            lines.append(f"  [{kind}] {name}: {status} ({loc})")
+    else:
+        lines.append("Artifacts: none")
+
+    zarr_path = summary.get("_zarr_path")
+    if zarr_path:
+        lines.append("")
+        lines.append(f"Zarr store: {zarr_path}")
+
+    return "\n".join(lines)
+
+
+def runs(
+    flowsheet: str = typer.Argument(..., help="Path to the flowsheet JSON"),
+    run_id: str = typer.Argument(
+        None,
+        help="Show this run's result summary. Use 'latest' for the most recent run.",
+    ),
+    schema: bool = typer.Option(
+        False,
+        "--schema",
+        help="Print the result schema JSON instead of the summary.",
+    ),
+):
+    """List runs for a flowsheet, or inspect one run's Zarr result summary."""
+    base = flowsheet_basename(flowsheet)
+    archive_path = os.path.join(output_root(), f"{base}.pfarchive")
+
+    if not os.path.isdir(archive_path):
+        logger.error(
+            f"No archive found for '{flowsheet}' at {archive_path}. "
+            "Run 'pf run' first."
+        )
+        raise typer.Exit(code=1)
+
+    archive = ProcessStateArchive(archive_path)
+    latest = archive.latest_run()
+    latest_id = latest.run_id if latest is not None else None
+
+    if run_id is not None:
+        resolved_id = latest_id if run_id == "latest" and latest_id else run_id
+        if resolved_id != run_id and latest_id is None:
+            logger.error(f"No latest run found in {archive_path}.")
+            raise typer.Exit(code=1)
+
+        if resolved_id not in archive.list_runs():
+            logger.error(f"Run '{resolved_id}' not found in {archive_path}/runs.")
+            raise typer.Exit(code=1)
+
+        zarr_path = _zarr_path(archive_path, resolved_id)
+
+        if schema:
+            schema_path = zarr_path + ".schema.json"
+            if not os.path.isfile(schema_path):
+                logger.error(f"No schema found for run '{resolved_id}'.")
+                raise typer.Exit(code=1)
+            with open(schema_path, "r", encoding="utf-8") as f:
+                typer.echo(f.read())
+            return
+
+        manifest = archive.load_run(resolved_id)
+        summary = summarize_zarr_store(zarr_path)
+        summary["_zarr_path"] = zarr_path
+        typer.echo(_format_run_details(manifest, summary))
+        return
+
+    # List all runs with a one-line summary.
+    run_ids = archive.list_runs()
+    if not run_ids:
+        typer.echo(f"No runs found for '{flowsheet}'.")
+        return
+
+    header = f"{'RUN ID':<28} {'TIMESTAMP':<22} {'LATEST':<7} {'SUMMARY':<30}"
+    typer.echo(header)
+    typer.echo("-" * len(header))
+    for rid in run_ids:
+        manifest = archive.load_run(rid)
+        if manifest is None:
+            continue
+        marker = "*" if rid == latest_id else " "
+        zarr_path = _zarr_path(archive_path, rid)
+        summary = summarize_zarr_store(zarr_path)
+        one_liner = _one_line_summary(summary)
+        typer.echo(
+            f"{rid:<28} {_humanize_timestamp(manifest.timestamp):<22} {marker:<7} {one_liner:<30}"
+        )
+    typer.echo("")
+    typer.echo(
+        "'*' marks the latest run. "
+        "'pf runs <flowsheet> <run_id>' shows the result summary. "
+        "Use 'latest' as the run id for the most recent run."
+    )