openprocess 0.13.2__tar.gz → 0.15.0__tar.gz

{openprocess-0.13.2/openprocess.egg-info → openprocess-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.13.2
+Version: 0.15.0
 Summary: Process mining, Petri nets and workflows in one open app: every algorithm visible, every result reproducible, every step teachable
 Author: Sam Struthers
 License: MIT
@@ -18,6 +18,7 @@ Classifier: Topic :: Education
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy>=1.24
 Provides-Extra: app
 Requires-Dist: PySide6>=6.6; extra == "app"
 Requires-Dist: certifi; extra == "app"
@@ -28,7 +29,6 @@ Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: mcp>=2.3; extra == "dev"
 Provides-Extra: science
-Requires-Dist: numpy>=1.24; extra == "science"
 Requires-Dist: pandas>=2.0; extra == "science"
 Requires-Dist: scipy>=1.10; extra == "science"
 Requires-Dist: matplotlib>=3.7; extra == "science"
@@ -494,6 +494,9 @@ links to the definitions it builds on; **Help ▸ Definitions** lists them all.
   - Time unit (Auto, or seconds up to years) and a grid step you can type in.
   - Colour and shape by any attribute. The default palette can be changed
     per value: right-click a value in the legend and pick its colour.
+  - A log of a million events (the BPI Challenge logs) pans, zooms and
+    answers the pointer without a pause: the dots are numpy arrays and a
+    dense picture is rasterised a colour at a time, not a dot at a time.
 - **Discover** hands the log to an analysis in Mine (**Discover in Mine →**),
   where the miner is a box with its result, its *How* and its *Code*:
   - α-algorithm, which shows its eight steps;
@@ -759,7 +762,7 @@ renders every page offscreen into `docs/screenshots/`, so run it after a
 change to the app's looks.
 
 The engines (`openprocess.mining`, `openprocess.ml`, `openprocess.sim`, `openprocess.analysis`)
-have **no dependencies**, so they work in a notebook or a script:
+need **nothing but numpy**, so they work in a notebook or a script:
 
 ```python
 from openprocess.mining import read_xes, inductive_miner
@@ -788,14 +791,28 @@ Miner, a fitness check), *Compare discovery* (three miners side by side),
 confidence* (bootstrap intervals, a test and a plot; needs the `science`
 extra) and *Predict the next activity*. Or start empty.
 
-| The canvas: *Compare discovery*, three miners side by side | Summary: every box's key figure, and the process map |
+| The canvas: *Compare discovery*, three miners side by side | Report: every box's result, in run order, on one page |
 |---|---|
-| ![The canvas of a Compare discovery analysis, the Compare box's table beside it](docs/screenshots/workflow-canvas.png) | ![The Summary view: a tile per box, the process map under them](docs/screenshots/workflow-summary.png) |
-
-- **The page is the canvas.** Its header has **Canvas | Summary**, then
-  **+ Add box**, **Run ▶**, and **⋯** for Re-run, Record, Export experiment
-  and Save. The sidebar beside it lists the folder's analyses and, folded
-  under them, its logs.
+| ![The canvas of a Compare discovery analysis, the Compare box's table beside it](docs/screenshots/workflow-canvas.png) | ![The Report view: a section per box with its result, a Steps outline beside them](docs/screenshots/workflow-report.png) |
+
+- **An analysis opens on its Report.** Its header has **Report | Canvas |
+  Runs**, then **+ Add box**, **Run ▶**, and **⋯** for Re-run, Record,
+  Export experiment and Save. The sidebar beside it lists the folder's
+  analyses and, folded under them, its logs.
+- **Report** is every box's result, in the order the boxes run, on one
+  scrolling page: a section per box with the group it is in, its name, the
+  line the canvas shows under it, its status, the result as the side panel
+  shows it (a table scrolls sideways inside its section when it is wider; a
+  figure keeps its proportions; a score gets a key-figure tile), its
+  settings as chips, and *Open ›*, *How* and *Code*, which open the box in
+  the side panel on the canvas. A slim *Steps* outline on the left lists
+  the sections, grouped as the canvas groups the boxes, with each box's
+  key figure; a click scrolls to the section, and on a narrow window the
+  outline folds into a *Steps* menu. Nothing is computed there: while a
+  run goes, each section is redrawn as its box reports; a box that has not
+  run says so, a failed one shows its error. The process map is the
+  *Directly-follows graph* box's result; an analysis without that box is
+  offered one in one click.
 - **+ Add box** (or a double-click on the canvas) opens every box, one
   section per group (Input, Filter, Discover, Check, Measure, Compare, Output,
   then Science, Predict, Coloured nets, Sweep and your own boxes), in a list that
@@ -809,12 +826,6 @@ extra) and *Predict the next activity*. Or start empty.
   notation…* in the sidebar land as boxes on the current analysis (or a new
   one named after the file). In a box's **Settings**, *Choose…* picks the
   file and the list beside it offers only the files the box can read.
-- **Summary** is the key figure of every box, in one place: a tile per box,
-  in the order the boxes run (a score's first metric, a table's size, a
-  log's cases, a net's places and transitions). Nothing is computed there:
-  a tile is the box's result, as on the canvas, and a tile opens the box.
-  The process map under the tiles is the *Directly-follows graph* box's
-  result; an analysis without that box offers to add it in one click.
 - **Connect** by dragging from the dot on the right of a box: while you drag,
   only the inputs that take that kind of result light up, so a wrong
   connection cannot be made. Click a wire and press Delete to remove it.
@@ -884,15 +895,15 @@ extra) and *Predict the next activity*. Or start empty.
   with the course's miners and checks on the 2AMI10 exam log.
 - **Connections** (at the bottom of the sidebar, or *View ▸ Connections*)
   draws what flows in, OpenProcess and its boxes, what flows out, and the
-  optional tools (pandas, numpy, scipy, matplotlib, …) with whether each is
+  optional tools (pandas, scipy, matplotlib, …) with whether each is
   installed, how to install it and the boxes it brings. All of it is read
   from the box library. *Install…* works in the downloaded app too: it carries
   pip and installs into a folder of your own (on a Mac,
   `~/Library/Application Support/OpenProcess/packages`), and the boxes that
   need the package come alive without a restart. PM4Py needs a Python
   install (`pip install pm4py`), as parts of it are built from source.
-- **Motion** is kept short: a space switch, the side panel and Canvas ↔
-  Summary settle in a fifth of a second, and a box pulses once when it
+- **Motion** is kept short: a space switch, the side panel and Report ↔
+  Canvas settle in a fifth of a second, and a box pulses once when it
   finishes. `OPENPROCESS_NO_MOTION=1` turns it off.
 
 ## Workflows from Python
@@ -949,7 +960,7 @@ See [Parallel work](docs/workflows.md#parallel-work) for the rules (each item
 from its own inputs, `flow.item_seed` for randomness). OpenProcess's own
 alignments and token replay run this way on large logs.
 
-`pip install -e ".[science]"` adds the pandas, NumPy, SciPy and matplotlib
+`pip install -e ".[science]"` adds the pandas, SciPy and matplotlib
 boxes (describe, bootstrap intervals, tests, plots).
 
 **Large logs.** A log above 20 MB is read into columns rather than objects,

{openprocess-0.13.2 → openprocess-0.15.0}/README.md

@@ -452,6 +452,9 @@ links to the definitions it builds on; **Help ▸ Definitions** lists them all.
   - Time unit (Auto, or seconds up to years) and a grid step you can type in.
   - Colour and shape by any attribute. The default palette can be changed
     per value: right-click a value in the legend and pick its colour.
+  - A log of a million events (the BPI Challenge logs) pans, zooms and
+    answers the pointer without a pause: the dots are numpy arrays and a
+    dense picture is rasterised a colour at a time, not a dot at a time.
 - **Discover** hands the log to an analysis in Mine (**Discover in Mine →**),
   where the miner is a box with its result, its *How* and its *Code*:
   - α-algorithm, which shows its eight steps;
@@ -717,7 +720,7 @@ renders every page offscreen into `docs/screenshots/`, so run it after a
 change to the app's looks.
 
 The engines (`openprocess.mining`, `openprocess.ml`, `openprocess.sim`, `openprocess.analysis`)
-have **no dependencies**, so they work in a notebook or a script:
+need **nothing but numpy**, so they work in a notebook or a script:
 
 ```python
 from openprocess.mining import read_xes, inductive_miner
@@ -746,14 +749,28 @@ Miner, a fitness check), *Compare discovery* (three miners side by side),
 confidence* (bootstrap intervals, a test and a plot; needs the `science`
 extra) and *Predict the next activity*. Or start empty.
 
-| The canvas: *Compare discovery*, three miners side by side | Summary: every box's key figure, and the process map |
+| The canvas: *Compare discovery*, three miners side by side | Report: every box's result, in run order, on one page |
 |---|---|
-| ![The canvas of a Compare discovery analysis, the Compare box's table beside it](docs/screenshots/workflow-canvas.png) | ![The Summary view: a tile per box, the process map under them](docs/screenshots/workflow-summary.png) |
-
-- **The page is the canvas.** Its header has **Canvas | Summary**, then
-  **+ Add box**, **Run ▶**, and **⋯** for Re-run, Record, Export experiment
-  and Save. The sidebar beside it lists the folder's analyses and, folded
-  under them, its logs.
+| ![The canvas of a Compare discovery analysis, the Compare box's table beside it](docs/screenshots/workflow-canvas.png) | ![The Report view: a section per box with its result, a Steps outline beside them](docs/screenshots/workflow-report.png) |
+
+- **An analysis opens on its Report.** Its header has **Report | Canvas |
+  Runs**, then **+ Add box**, **Run ▶**, and **⋯** for Re-run, Record,
+  Export experiment and Save. The sidebar beside it lists the folder's
+  analyses and, folded under them, its logs.
+- **Report** is every box's result, in the order the boxes run, on one
+  scrolling page: a section per box with the group it is in, its name, the
+  line the canvas shows under it, its status, the result as the side panel
+  shows it (a table scrolls sideways inside its section when it is wider; a
+  figure keeps its proportions; a score gets a key-figure tile), its
+  settings as chips, and *Open ›*, *How* and *Code*, which open the box in
+  the side panel on the canvas. A slim *Steps* outline on the left lists
+  the sections, grouped as the canvas groups the boxes, with each box's
+  key figure; a click scrolls to the section, and on a narrow window the
+  outline folds into a *Steps* menu. Nothing is computed there: while a
+  run goes, each section is redrawn as its box reports; a box that has not
+  run says so, a failed one shows its error. The process map is the
+  *Directly-follows graph* box's result; an analysis without that box is
+  offered one in one click.
 - **+ Add box** (or a double-click on the canvas) opens every box, one
   section per group (Input, Filter, Discover, Check, Measure, Compare, Output,
   then Science, Predict, Coloured nets, Sweep and your own boxes), in a list that
@@ -767,12 +784,6 @@ extra) and *Predict the next activity*. Or start empty.
   notation…* in the sidebar land as boxes on the current analysis (or a new
   one named after the file). In a box's **Settings**, *Choose…* picks the
   file and the list beside it offers only the files the box can read.
-- **Summary** is the key figure of every box, in one place: a tile per box,
-  in the order the boxes run (a score's first metric, a table's size, a
-  log's cases, a net's places and transitions). Nothing is computed there:
-  a tile is the box's result, as on the canvas, and a tile opens the box.
-  The process map under the tiles is the *Directly-follows graph* box's
-  result; an analysis without that box offers to add it in one click.
 - **Connect** by dragging from the dot on the right of a box: while you drag,
   only the inputs that take that kind of result light up, so a wrong
   connection cannot be made. Click a wire and press Delete to remove it.
@@ -842,15 +853,15 @@ extra) and *Predict the next activity*. Or start empty.
   with the course's miners and checks on the 2AMI10 exam log.
 - **Connections** (at the bottom of the sidebar, or *View ▸ Connections*)
   draws what flows in, OpenProcess and its boxes, what flows out, and the
-  optional tools (pandas, numpy, scipy, matplotlib, …) with whether each is
+  optional tools (pandas, scipy, matplotlib, …) with whether each is
   installed, how to install it and the boxes it brings. All of it is read
   from the box library. *Install…* works in the downloaded app too: it carries
   pip and installs into a folder of your own (on a Mac,
   `~/Library/Application Support/OpenProcess/packages`), and the boxes that
   need the package come alive without a restart. PM4Py needs a Python
   install (`pip install pm4py`), as parts of it are built from source.
-- **Motion** is kept short: a space switch, the side panel and Canvas ↔
-  Summary settle in a fifth of a second, and a box pulses once when it
+- **Motion** is kept short: a space switch, the side panel and Report ↔
+  Canvas settle in a fifth of a second, and a box pulses once when it
   finishes. `OPENPROCESS_NO_MOTION=1` turns it off.
 
 ## Workflows from Python
@@ -907,7 +918,7 @@ See [Parallel work](docs/workflows.md#parallel-work) for the rules (each item
 from its own inputs, `flow.item_seed` for randomness). OpenProcess's own
 alignments and token replay run this way on large logs.
 
-`pip install -e ".[science]"` adds the pandas, NumPy, SciPy and matplotlib
+`pip install -e ".[science]"` adds the pandas, SciPy and matplotlib
 boxes (describe, bootstrap intervals, tests, plots).
 
 **Large logs.** A log above 20 MB is read into columns rather than objects,

{openprocess-0.13.2 → openprocess-0.15.0}/openprocess/__init__.py

@@ -48,7 +48,7 @@ from .sim.simulator import Simulator
 #: The one place the version number is written (pyproject.toml, the update
 #: check and packaging/build.py read it from here).  A release is tagged
 #: "v" + this, e.g. v0.2.0.
-__version__ = "0.13.2"
+__version__ = "0.15.0"
 
 __all__ = [
     "Arc", "BindingElement", "CPNet", "Marking", "Multiset", "Page", "Place",

{openprocess-0.13.2 → openprocess-0.15.0}/openprocess/cli.py

@@ -517,8 +517,11 @@ def command_run(arguments: argparse.Namespace) -> int:
             return 1
         print(f"Every recorded result was reproduced ({len(record.results)} boxes).")
     elif arguments.save:
-        save(workflow, path, run, folder)
-        print(f"Recorded the results in {path.name}")
+        save(workflow, path, run, folder, previous=record)
+        if run.failed() and record.results:
+            print(f"A box failed, so {path.name} keeps the record of its last successful run")
+        else:
+            print(f"Recorded the results in {path.name}")
     return 0 if run.ok else 1
 
 

{openprocess-0.13.2 → openprocess-0.15.0}/openprocess/flow/figures.py

@@ -1,6 +1,6 @@
 """The key figure of a result: one number and a line, for a tile or a report.
 
-Shared by the Summary (:mod:`openprocess.gui.flow.summary`) and the HTML
+Shared by the Report (:mod:`openprocess.gui.flow.report`) and the HTML
 report (:mod:`openprocess.flow.report`), so both say the same thing about a
 result: a score's first metric, a table's size, a log's cases, a net's
 places and transitions, a map's activities and paths.

{openprocess-0.13.2 → openprocess-0.15.0}/openprocess/flow/record.py

@@ -242,8 +242,11 @@ def canonical(value: Any, _active: set[int] | None = None) -> Any:
         if isinstance(value, (list, tuple)):
             return [canonical(v, _active) for v in value]
         if dataclasses.is_dataclass(value) and not isinstance(value, type):
+            # A field named with a leading underscore is a cache or a working
+            # value (a DFG's per-arc means and medians, say), not content.
             fields = {f.name: canonical(getattr(value, f.name, None), _active)
-                      for f in dataclasses.fields(value) if f.name not in _NOT_CONTENT}
+                      for f in dataclasses.fields(value)
+                      if not f.name.startswith("_") and f.name not in _NOT_CONTENT}
             return {"type": type(value).__name__, **fields}
         attributes = getattr(value, "__dict__", None)
         if isinstance(attributes, dict):
@@ -456,12 +459,16 @@ def differences(record: Record, workflow: Workflow, folder: str | Path | None =
 # Files
 # ---------------------------------------------------------------------------
 def save(workflow: Workflow, path: str | Path, run: Run | None = None,
-         folder: str | Path | None = None, lock: bool = True, history: list[dict] | None = None) -> Record:
+         folder: str | Path | None = None, lock: bool = True, history: list[dict] | None = None,
+         previous: Record | None = None) -> Record:
     """Write the workflow and its record to ``path``; returns the record.
-    ``history``: the analysis's snapshots (see :mod:`.snapshots`), kept in the file."""
+    ``history``: the analysis's snapshots (see :mod:`.snapshots`), kept in the file.
+    ``previous``: the file's record so far; see :func:`carried`."""
     path = Path(path)
     folder = folder if folder is not None else path.parent
     record = make_record(workflow, run, folder, lock)
+    if previous is not None:
+        record = carried(record, previous, workflow, run)
     record.history = list(history or [])
     data = {"format": FORMAT, **workflow.to_dict(), "record": record.to_dict()}
     text = json.dumps(data, indent=2, ensure_ascii=False, default=str)
@@ -471,6 +478,30 @@ def save(workflow: Workflow, path: str | Path, run: Run | None = None,
     return record
 
 
+def carried(record: Record, previous: Record, workflow: Workflow, run: Run | None) -> Record:
+    """The record to write, given the file's ``previous`` one: the record of the
+    last successful run stays until a successful run replaces it.
+
+    No run, or a run in which a box failed (the input file was not found, say),
+    leaves the previous record as it was, results of boxes since removed aside.
+    A run in which no box failed replaces it; a box that could not run here (a
+    library it needs is missing) keeps its recorded fingerprint if the scheme is
+    the same, and an input file that is missing now keeps the fingerprint
+    recorded when it was read."""
+    still = {k: v for k, v in previous.results.items() if k in workflow.nodes}
+    if run is None or run.failed():
+        return Record(**{**previous.__dict__, "results": still})
+    if previous.scheme == record.scheme:
+        record.results = {**still, **record.results}
+    for entry in record.inputs:
+        if entry["sha256"] == "missing":
+            then = next((i for i in previous.inputs if i["node"] == entry["node"]
+                         and i["setting"] == entry["setting"] and i["file"] == entry["file"]), None)
+            if then is not None:
+                entry["sha256"] = then["sha256"]
+    return record
+
+
 def load(path: str | Path, library=None) -> tuple[Workflow, Record]:
     """Read a ``.cpnflow`` file."""
     data = json.loads(Path(path).read_text(encoding="utf-8"))

{openprocess-0.13.2 → openprocess-0.15.0}/openprocess/flow/workflow.py

@@ -348,12 +348,12 @@ class Workflow:
             "name": self.name,
             "boxes": [{"id": n.id, "box": n.box, "settings": {k: (v.to_json() if is_sweep(v) else _json_value(v))
                                                              for k, v in n.settings.items()},
-                       "position": list(n.position), **({"title": n.title} if n.title else {}),
-                       **({"layout": {k: list(v) for k, v in n.layout.items()}} if n.layout else {})}
+                       "position": _coordinates(n.position), **({"title": n.title} if n.title else {}),
+                       **({"layout": {k: _coordinates(v) for k, v in n.layout.items()}} if n.layout else {})}
                       for n in self.nodes.values()],
             "connections": [{"from": e.source, "output": e.output, "to": e.target, "input": e.input}
                             for e in self.edges],
-            "groups": [{"id": g.id, "name": g.name, "boxes": list(g.members), "position": list(g.position)}
+            "groups": [{"id": g.id, "name": g.name, "boxes": list(g.members), "position": _coordinates(g.position)}
                        for g in self.groups.values()],
         }
 
@@ -387,6 +387,12 @@ class Workflow:
         return wf
 
 
+def _coordinates(point) -> list:
+    """A position for the file: the canvas works in floats, but a whole number
+    is written as one (a file opened and saved keeps its ``[0, 360]``)."""
+    return [int(v) if isinstance(v, float) and v.is_integer() else v for v in point]
+
+
 def _stand_in(library, box_id: str) -> str | None:
     """A folder box's id holds a hash of its file's absolute path, so the same
     file in a folder that was moved, copied or imported elsewhere has another

{openprocess-0.13.2 → openprocess-0.15.0}/openprocess/gui/flow/page.py

@@ -1,9 +1,11 @@
-"""The Workflows page: the canvas, *+ Add box*, and a side panel on demand.
-
-The page opens with the workflow alone on its canvas.  *+ Add box* in the
-header (or a double-click on the canvas) opens the box picker
-(:mod:`.picker`).  Click a box and the side panel appears beside the
-canvas, on *Result* (the viewer for its output type); its other tabs are
+"""The Workflows page: the Report, the canvas, *+ Add box*, and a side panel on demand.
+
+The page opens on its *Report* (:mod:`.report`): every box's result, in run
+order, on one scrolling page.  *Canvas* in the header is the boxes and
+wires, *Runs* every finished run.  *+ Add box* (or a double-click on the
+canvas) opens the box picker (:mod:`.picker`).  Click a box on the canvas
+(or *Open ›* under its section of the Report) and the side panel appears
+beside the canvas, on *Result* (the viewer for its output type); its other tabs are
 *How* (what it reported while it ran: notes, intermediate values, the
 derivation), *Code* (its source) and *Settings* (one control per setting).
 Click the canvas, or the panel's ✕, and the panel goes again.  Change a
@@ -50,11 +52,13 @@ from ..studio.widgets import (Card, ElidedLabel, NoticeBar, PageHeader, Segmente
 from ..studio.workers import run_in_background
 from .canvas import WorkflowScene, WorkflowView
 from .picker import BoxPicker, input_box_for
+from .report import ReportWidget
 from .runs import RunsWidget
-from .summary import SummaryWidget
 from .viewers import SettingsWidget, code_widget, how_widget, pop_out, result_widget, status_text
 
 TABS = ["Result", "How", "Code", "Settings"]
+#: The header switch's views, and the body's pages in the same order.
+REPORT, CANVAS, RUNS = 0, 1, 2
 HINT = "Click a box to see what it gives. Drag from the dot on its right to connect it to another."
 
 
@@ -155,6 +159,7 @@ class WorkflowPage(QWidget):
         self._setting_timer.setInterval(400)
         self._setting_timer.timeout.connect(self._apply_pending_settings)
         self._pending: dict[str, dict] = {}
+        self._record_pending = False
 
         root = QVBoxLayout(self)
         root.setContentsMargins(0, 0, 0, 0)
@@ -175,15 +180,15 @@ class WorkflowPage(QWidget):
                     self.refresh_title()
             run_in_background(lambda: reproducibility.status(workflow, record, None, folder), first_check,
                               lambda _message: None)
-        # Canvas: the boxes and wires.  Summary: every result's figure, and the process map.
-        self.summary_switch = SegmentedControl(["Canvas", "Summary", "Runs"], compact=True)
-        self.summary_switch.setToolTip("Canvas: the boxes and wires.\nSummary: every result's key "
-                                       "figure, and the process map.\nRuns: every finished run, two compared.")
+        # Report: every box's result, in run order.  Canvas: the boxes and wires.
+        self.view_switch = SegmentedControl(["Report", "Canvas", "Runs"], compact=True)
+        self.view_switch.setToolTip("Report: every box's result, in the order the boxes run.\nCanvas: the "
+                                    "boxes and wires.\nRuns: every finished run, two compared.")
         record = getattr(document, "record", None)
         #: The last runs, with what changed before each (kept in the workflow file).
         self.history = snapshots.History.from_dict(record.history if record is not None else [])
-        self.summary_switch.changed.connect(self.show_view)
-        self.header.actions.addWidget(self.summary_switch)
+        self.view_switch.changed.connect(self.show_view)
+        self.header.actions.addWidget(self.view_switch)
         self.keep_button = button("Keep", self.keep_requested.emit, kind="primary",
                                   tooltip="Save this workflow into the folder")
         self.keep_button.setVisible(False)
@@ -258,16 +263,15 @@ class WorkflowPage(QWidget):
         splitter.reset_requested.connect(self.reset_layout)
         wrapper = QWidget()
         wrapper.setLayout(vbox(splitter, margins=(20, 0, 20, 16)))
-        self.summary = SummaryWidget(self)
-        self.summary.tile_clicked.connect(self._tile_clicked)
-        summary_wrapper = QWidget()
-        summary_wrapper.setLayout(vbox(scroll(self.summary), margins=(20, 0, 20, 16)))
+        self.report = ReportWidget(self)
+        report_wrapper = QWidget()
+        report_wrapper.setLayout(vbox(self.report, margins=(20, 0, 20, 16)))
         self.runs = RunsWidget(self)
         runs_wrapper = QWidget()
         runs_wrapper.setLayout(vbox(scroll(self.runs), margins=(20, 0, 20, 16)))
         self.body = QStackedWidget()
+        self.body.addWidget(report_wrapper)
         self.body.addWidget(wrapper)
-        self.body.addWidget(summary_wrapper)
         self.body.addWidget(runs_wrapper)
         root.addWidget(self.body, 1)
         self._picker: BoxPicker | None = None
@@ -282,6 +286,8 @@ class WorkflowPage(QWidget):
                   if self.selected in self.workflow.groups else None)
         self._refresh_custom_bar()
         self._render_panel()
+        # A workflow opens on its Report; an empty one on the canvas, where boxes are added.
+        self.show_view(REPORT if self.workflow.nodes else CANVAS)
         QTimer.singleShot(0, self.view.fit)
         if not self.workflow.nodes:
             self.status.emit("An empty workflow: press + Add box, or double-click the canvas")
@@ -302,17 +308,17 @@ class WorkflowPage(QWidget):
         self.select(None)
 
     def show_view(self, index: int) -> None:
-        """Canvas (0), Summary (1) or Runs (2); the latter two are rebuilt when shown."""
+        """Report (0), Canvas (1) or Runs (2); the Report and Runs are brought up to date when shown."""
         if self.body.currentIndex() != index:
             self.body.setCurrentIndex(index)
             motion.lift(self.body)
-        if self.summary_switch.index() != index:
-            self.summary_switch.blockSignals(True)
-            self.summary_switch.buttons[index].setChecked(True)
-            self.summary_switch.blockSignals(False)
-        if index == 1:
-            self.summary.refresh()
-        elif index == 2:
+        if self.view_switch.index() != index:
+            self.view_switch.blockSignals(True)
+            self.view_switch.buttons[index].setChecked(True)
+            self.view_switch.blockSignals(False)
+        if index == REPORT:
+            self.report.refresh()
+        elif index == RUNS:
             self.runs.refresh()
 
     def apply_snapshot(self, snapshot: snapshots.Snapshot) -> None:
@@ -335,15 +341,18 @@ class WorkflowPage(QWidget):
             return
         self._mark_edited()
         self._render_panel()
-        self.show_view(0)
+        self.show_view(REPORT)                      # the results of those settings, as they come
         self.status.emit(f"Settings of the run at {snapshot.taken.replace('T', ' ')} are back on "
                          f"{len(changed)} box{'es' if len(changed) != 1 else ''}; running")
         self.run_from(changed)
 
-    def _tile_clicked(self, node_id: str) -> None:
-        """A Summary tile: that box's Result, on the canvas."""
-        self.show_view(0)
-        self.select(node_id, 0)
+    def open_box(self, node_id: str, tab: int = 0) -> None:
+        """A Report section's *Open ›*, *How* or *Code*: that box in the side panel, on the canvas."""
+        self.select(node_id, tab)
+
+    def result_view(self, node, result: Result | None) -> QWidget:
+        """The side panel's Result tab for ``node`` showing ``result``; the Report draws each box with it."""
+        return self._tab_widget(node, self.workflow.spec(node), result, 0)
 
     @property
     def dock(self) -> str:
@@ -460,7 +469,8 @@ class WorkflowPage(QWidget):
         return QPointF(rect.left() + 30 + count * 24, rect.bottom() - 150 - count * 12)
 
     def add_box_in_view(self, box_id: str, settings: dict | None = None):
-        """Add ``box_id`` where it can be seen."""
+        """Add ``box_id`` where it can be seen: on the canvas, brought up if another view is showing."""
+        self.show_view(CANVAS)
         return self.add_box(box_id, self.free_spot(), settings)
 
     def quick_add(self, where: QPointF) -> None:
@@ -491,8 +501,9 @@ class WorkflowPage(QWidget):
 
     def add_box_fed_by(self, box_id: str, source_id: str | None):
         """Add a box and connect it to ``source_id``'s output (the first input
-        that takes it), as dropping a wire would; then it runs."""
-        node = self.add_box_in_view(box_id)
+        that takes it), as dropping a wire would; then it runs.  The page stays
+        on the view it was asked from (the Report offers the process map this way)."""
+        node = self.add_box(box_id, self.free_spot())
         if source_id is not None and source_id in self.workflow.nodes:
             ok, detail = self.workflow.can_connect(source_id, node.id)
             if ok:
@@ -628,6 +639,10 @@ class WorkflowPage(QWidget):
         self._show_status(result)
         if self.selected == result.node:
             self._render_panel()
+        if self.body.currentIndex() == REPORT:
+            self.report.update_box(result)
+        else:
+            self.report.stale = True
 
     def _show_status(self, result: Result) -> None:
         if result.variant != 0:
@@ -661,11 +676,16 @@ class WorkflowPage(QWidget):
         self._render_panel()
         if isinstance(outcome, Run) and not outcome.stopped and not self._has_queue:
             if self.history.add(snapshots.take(self.workflow, outcome, self.history.latest)) \
-                    and self.body.currentIndex() == 2:
+                    and self.body.currentIndex() == RUNS:
                 self.runs.refresh()
+            if self._record_pending:
+                self._record_pending = False
+                self.document.dirty = True
             self.ran.emit()
-        if self.body.currentIndex() == 1:
-            self.summary.refresh()
+        if self.body.currentIndex() == REPORT:
+            self.report.refresh()
+        else:
+            self.report.stale = True
         if self._has_queue or (isinstance(outcome, Run) and outcome.stopped):
             queued, self._queued, self._has_queue = self._queued, None, False
             if queued is not None and isinstance(outcome, Run) and outcome.stopped:
@@ -828,6 +848,8 @@ class WorkflowPage(QWidget):
         if tab is not None:
             self.tab = tab
             self._opening_tab = tab
+        if node_id is not None:
+            self.show_view(CANVAS)                  # the side panel lives beside the canvas
         # The scene clears its selection before selecting: without the guard,
         # the panel would close and reopen (back on Result) at every select.
         self._selecting = True
@@ -1176,11 +1198,16 @@ class WorkflowPage(QWidget):
     def write_to(self, path: str, quiet: bool = False) -> None:
         """Save the workflow and its record to ``path`` (the window's Keep / Save As)."""
         target = Path(path)
-        self.workflow.name = target.stem if target.stem else self.workflow.name
+        if target.stem and (not self.document.path or Path(self.document.path) != target):
+            self.workflow.name = target.stem          # Keep / Save As: named after the file; a save keeps the name
         self.document.record = records.save(self.workflow, target, self.run, self.folder or target.parent,
-                                            history=self.history.to_dict())
+                                            history=self.history.to_dict(),
+                                            previous=getattr(self.document, "record", None))
         self.document.path = str(target)
         self.document.dirty = False
+        # Saved while a run was going: the record is of the run before, so the one
+        # finishing wants saving too.
+        self._record_pending = self._running
         self.refresh_reproducibility()
         if not quiet:
             self.status.emit(f"Saved {target.name}")