web: the mark of a reading follows the folder the walk stands in, and the head of the tree never wears it

The mark was pinned to the folder a reading was kept to, which is a fine thing
to say and no use at all to look at: a reading kept to the roll is kept to the
roll for the whole of an afternoon, so the one row that said anything said the
same word from the first frame to the last while the walk went through every
folder under it. The reader asking which folder is being read was told, in
answer, which folder they had asked about. A reading is where it is, not where
it was pointed, and where it is is a thing only the reading knows — so the walk
now tells it. The frame in hand names the folder it sits in, and the progress
carried to the screen says so with the rest, which is where the column reads it.

The mark is a way down and not a single row: the folder being read says so, and
so does every folder above it. That is what keeps a reading visible under a
branch folded shut — the row doing the work is the row the fold takes away, and
the rows above it are all a reader would have left. Two rows say the same thing
and no more, which is the point: the eye follows the marks down to the work.

The head of the tree is never one of them, and this is the rule that survives
from the last reading of the question. A roll is the head of everything under
it, and a head marked while one folder below it is read says the whole of the
tree is being read — an answer that is both loud and false, and worse than the
silence it replaced. So the mark stops one row short of the top. The one case
left bare is a reading whose frames sit in the roll's own folder and nowhere
else: there is no row between the work and the head, and a flat roll is a roll
in which the toolbar's line, which names the count, is the whole of what there
is to say.

docker/frontend/src/Library.tsx

@@ -1065,20 +1065,20 @@ export function Library() {
                   >
                     {rows.map((n) => {
                       const folder = folders.find((f) => f.name === n.key.split('/')[0]) ?? null;
-                      // The rows that say a reading is under way are the folder it
-                      // was kept to and every folder above it on the way down, and
-                      // never a folder under it, which the reading has not reached.
-                      // Depth is why: a branch folded shut hides the row being read,
-                      // and the rows above it are what keeps the work in sight while
-                      // the folder doing it is out of sight. The roll's own row is
-                      // the exception, and says so only when the roll itself is what
-                      // is being read — a roll asked to speak for one branch of
-                      // itself tells the reader the whole of it is being read, which
-                      // is the one answer a deep tree cannot afford.
+                      // The row that says a reading is under way is the folder the
+                      // reading stands in — not the folder it was pointed at, which
+                      // would be the same row for the whole of an afternoon while
+                      // the work went on somewhere the reader cannot see — together
+                      // with every folder above it, so a branch folded shut still
+                      // shows the work going on under it. The roll's own row is
+                      // never one of them: it is the head of everything below it,
+                      // and a head that says all of a tree is being read says
+                      // nothing about the folder the reading is actually in. The
+                      // frames that sit in the roll's own folder are the one case
+                      // left bare, and the toolbar's line is what carries them.
                       const dir = relOf(n.key);
-                      const from: string | null = live && live.folder === folder?.name ? live.progress.from : null;
-                      const scanning =
-                        dir !== null && from !== null && (dir === '' ? from === '' : dir === from || from.startsWith(dir));
+                      const at = live && live.folder === folder?.name && live.progress.at ? `${live.progress.at}/` : null;
+                      const scanning = dir !== null && dir !== '' && at !== null && (dir === at || at.startsWith(dir));
                       const under = parents.has(n.key);
                       return (
                         <button