Reader: come back to where you were reading

[thomwolf]

Reported on a phone against #58: coming back to a session did not put the reader
where you had left it.

Rewritten on top of #55, which landed while this was open and changed the
premise. The original version of this PR anchored on page.offset + exchange.at
against the old read-the-last-400-turns reader; #55 replaced that with byte
windows that page backwards, so that anchor could not survive and the PR was
rebuilt rather than rebased.

What main does now, measured

coming back after a discard or reload	lands on
before #55	turn 1 — the top, which is what was reported
main today (#55)	turn 59/60 — the end
with this PR	turn 26 — where you had scrolled to

So #55 already fixed the reported symptom. What is left is the actual promise:
opening on the end is right for a conversation you have not read, and wrong for
one you were half-way up. In-app navigation already survived either way — the pane
stays mounted and the browser preserves the scroll box across the display: none
that hides a warm tile — so this is entirely about the cold mount: a reload, an
evicted tab, the Hub rebuilding the Space's iframe.

Why the anchor is a turn timestamp

The windowed reader forces it. Exchanges regroup as older windows arrive: the
one at the top of the list is a fragment whose prompt was in the window not yet
read, and the two become one exchange when it lands. So no React key, no list
index and no pixel offset identifies a place for longer than one fetch. A turn's
ts comes from the transcript and never moves; off then only carries where
inside that turn you were.

If the remembered turn is not in the window the reader opened with, it pages
backwards to find it — through the same public loadOlder() a scroll would use.
Nothing in lib/traceWindows.ts changed, so #55's cursors, its one-request-at-a-
time guard and its live tailing are all untouched. Bounded to six windows: a
remembered position is not worth walking a 19 MB transcript for, and past that it
stays on the end, which is where the reader would have been anyway.

Three rules that decide whether it feels right

• Nothing is remembered until you have moved the view, and the evidence is a
  gesture — wheel, touch, pointer, keys, the turn nav, the load-earlier button —
  never a scroll event. A scroll fires when the reader re-anchors under a
  prepend, and gating on it filed positions the reader never chose. This is also
  what keeps Trace reader: open on the last exchange, page backwards by byte window #55's open-on-the-end landing intact for a session you merely glanced
  at.
• If you were at the end, you return to the new end — not to the row that used
  to be last. Six turns may have arrived while you were away, and they are what you
  came back for.
• A turn that cannot be reached degrades to the end, not to the top.

Bounded to 100 sessions, oldest first. No expiry, deliberately: unlike a draft
this is not text you typed, so it carries nothing worth forgetting for its own
sake. A v1 blob from the earlier anchor scheme is dropped rather than misread.
Quota failures and denied storage both degrade in silence.

Verified by running it

A local server at a 390×844 phone viewport, with unmodified main as a
control. 20 checks; the control fails exactly the seven that matter:

                                                     main    this PR
the reader is where I left it (switching agents)      PASS     PASS
still where I left it after a trip to the list        PASS     PASS
a discard comes back to the same place / same turn    FAIL     PASS
a reload comes back to the same place / same turn     FAIL     PASS
it is delta's position, not everyone's                FAIL     PASS
a position in a window we did NOT open with:
  it paged back and found the turn                    FAIL     PASS
  and it is not just sitting on the end               FAIL     PASS
never scrolled -> still lands on the end, stores none PASS     PASS
was at the end -> come back to the NEW end            PASS     PASS
an unreachable turn degrades to the end               skip     PASS
a corrupt store does not break the reader             PASS     PASS

The multi-window check uses a 580 KB fixture — several of the reader's 384 KB
windows — because that is the only way to exercise "the turn you were on is not in
the window we opened with". The "worked while I was away" check appends real turns
to the transcript the dev server is reading rather than mocking a response.

Also re-ran #58's 25 draft checks and the joint journey on this build (no
regression), plus tsc --noEmit, npm test and a production build.

Two bugs found by running rather than reading, both worth recording:

1. The landing never fired on a quiet trace. It was armed in a passive effect
   and applied in a layout effect — and layout effects run first, so nothing
   tried until the next render, which a quiet trace does not have. It now attempts
   the seek the moment it is armed, and again on every window that arrives.
2. Gating on scroll was not enough (see above). Found on the deployed Space
   and not locally, where the pane is 41px taller and had less slack to re-anchor
   into. The harness now scrolls with mouse.wheel rather than by assigning
   scrollTop, which is a truer test of the same path.

Not covered

• A real iOS device. The discard is simulated as pagehide{persisted:false} plus
  a fresh document in the same browsing context, which is what the browser does on
  revisiting a discarded tab.
• readingPosition.ts repeats the monotonic stamp and quota-safe write from
  drafts.ts. A conscious choice: the policies differ (drafts expire and are
  size-capped, a position is count-bounded and permanent), and a shared abstraction
  wanted four parameters to say so. Worth unifying if a third case appears.

🤖 Generated with Claude Code