List the steps, and let a photographer step straight to one

Undo answers "take back the last thing", which is the question asked about a
mistake just noticed. It is the wrong instrument for one noticed six
adjustments later: eight presses, each changing the picture, with no way to see
how far back the mistake is without passing through it. A step is a whole
state, so arriving from six away costs what arriving from one does — which is
what makes a row worth making clickable rather than decorative.

`Edit::Discrete` had to go for the list to be worth drawing. Seventeen call
sites recorded the same anonymous step, which is fine for deciding whether two
changes are one gesture and useless for a panel: seventeen rows reading
"Discrete" is not a history. Every variant now carries enough to name itself,
and the compiler enumerated the sites that had to start saying so. A step that
moved a parameter is still named out of the descriptor, so an operation added
as a YAML declaration appears in the history correctly named with nothing
written for it (FR-DEV-3c).

Choosing a film stock was not undoable at all. The pick went straight to
`choose_film`, which nothing on the history's path ever sees. `pick_film`
records it, and is separate because the same call is also how a *restored* edit
gets its tables back — recording that would push a step for the undo the
photographer had just asked for.

The list is rebuilt off a revision rather than off every redraw. A drag ends in
a redraw per frame while folding into one step, so the unconditional version
would tear down and recreate every row sixty times a second to arrive back at
the list already on screen. The counter is process-wide: a per-instance one
starts every photograph at the same number, so a frontend holding "the revision
I last drew" would keep the previous image's steps on screen — invisible while
every image opens with one identical row, and a wrong-photograph bug the moment
persisted history means it does not.

The step names that no descriptor can supply are constants with a roll, and a
test walks the roll rather than a second copy of it. `resolve` splits so that
"is this catalogued?" can be asked: `derive` turns `history.mask_toggled` into
"Mask Toggled", which names a field rather than an act and, being perfectly
readable, is a mistake nobody would look at twice.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

ui/dr-ui/src/lib.rs

@@ -43,7 +43,7 @@ mod sidecar_cache;
 mod spots_ui;
 mod trash;
 
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
@@ -1303,9 +1303,16 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
     //
     // Called on every slider change, so it must do no more than run the
     // adjust pass — the demosaic is not repeated.
+    // TRACES: FR-DEV-5
+    // The history revision the panel was last built from. See the use below:
+    // the list is rebuilt when it would read differently, not when the picture
+    // is redrawn, and those are very different rates.
+    let drawn_history: Rc<Cell<Option<u64>>> = Rc::new(Cell::new(None));
+
     let render_now: Render = {
         let session = session.clone();
         let viewport = viewport.clone();
+        let drawn_history = drawn_history.clone();
         Rc::new(move |window: &AppWindow, draft: bool| {
             let mut slot = session.borrow_mut();
             let Some(s) = slot.as_mut() else { return };
@@ -1318,6 +1325,20 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
             window.set_can_undo(s.can_undo());
             window.set_can_redo(s.can_redo());
 
+            // TRACES: FR-DEV-5 | FR-DEV-7
+            // The list, on the same path and for the same reason — but only
+            // when it would read differently. A drag ends in a redraw per
+            // frame while folding into one step, so an unconditional rebuild
+            // here would tear down and recreate every row of the panel sixty
+            // times a second to arrive back at the list already on screen.
+            let revision = s.history_revision();
+            if drawn_history.get() != Some(revision) {
+                drawn_history.set(Some(revision));
+                window
+                    .set_history_rows(slint::ModelRc::new(slint::VecModel::from(s.history_rows())));
+                window.set_undo_label(s.undo_label().into());
+            }
+
             // TRACES: FR-DEV-3
             // Which part of the region overlay the view is showing. Here
             // rather than in the panel's own sync because a pan or a zoom
@@ -2089,7 +2110,7 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
                     .and_then(dr_film::find)
                     .and_then(dr_film::default_print)
                     .is_some();
-                s.choose_film(*stock, print);
+                s.pick_film(*stock, print);
             }
             sync_rows(&w, &rows, &session);
             redraw(&w);
@@ -2103,7 +2124,7 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
             let Some(w) = weak.upgrade() else { return };
             if let Some(s) = session.borrow_mut().as_mut() {
                 if let Some((stock, _)) = s.film().map(|(a, b)| (a.to_string(), b)) {
-                    s.choose_film(Some(&stock), print);
+                    s.pick_film(Some(&stock), print);
                 }
             }
             sync_film(&w, &session);
@@ -2149,6 +2170,27 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
         });
     }
 
+    // TRACES: FR-DEV-5 | FR-DEV-7
+    // Clicking a row. Arriving six steps away costs what arriving from one
+    // does, because a step is a whole state — see `History::go_to`.
+    {
+        let weak = window.as_weak();
+        let session = session.clone();
+        let redraw = redraw.clone();
+        let rows = rows.clone();
+        window.on_history_picked(move |index| {
+            let Some(w) = weak.upgrade() else { return };
+            let stepped = session
+                .borrow_mut()
+                .as_mut()
+                .is_some_and(|s| s.go_to_history(index));
+            if stepped {
+                sync_rows(&w, &rows, &session);
+                redraw(&w);
+            }
+        });
+    }
+
     // ---- zoom, pan and crop ---------------------------------------------
     //
     // Zoom and pan are viewing state and touch no parameter, so unlike the