create-walle 0.10.1 → 0.10.2

package/template/coding-task-manager/public/js/core/session-selectors.js

@@ -94,7 +94,11 @@ function _projectSessionParked(s, options) {
       ? `${idleMin ? 'Paused after ' + idleMin + ' minutes of inactivity. ' : 'Paused after inactivity. '}Your conversation and working directory are preserved.`
       : reason === 'cap' || reason === 'prewarm-cap' || reason === 'interactive-preempt'
         ? 'Paused to keep the live-session limit available. Your conversation and working directory are preserved.'
-        : 'Paused to relieve system memory pressure. Your conversation and working directory are preserved.';
+        // Hub WP-6: a box-owned session the hub cannot reach shows its last known state; the box
+        // still owns (and may still be running) it.
+        : reason === 'remote-mirror'
+          ? `Runs on ${String(s.meta?.machineName || s.meta?.machine_name || '') || 'another machine'}, which is not reachable right now. This is its last known state; it updates when that machine is back.`
+          : 'Paused to relieve system memory pressure. Your conversation and working directory are preserved.';
   _projectSessionLifecycle(s, 'parked', { title: 'Session parked', detail, blocked });
 }
 

package/template/coding-task-manager/public/js/history-app-seam.js

@@ -172,6 +172,11 @@
       // D-2 (transcript-history-fidelity WP-0): carry the server's human-readable refusal
       // cause alongside the code, so the toast can say WHY, not just which code refused.
       err.reason = (body && body.reason) || '';
+      // source-missing diagnosis: the raw-Codex lane reports WHY in `coverage.reason`/`meta.reason`
+      // (`base(state, generation, reason)` in lib/raw-codex-history-window.js), never in a top-level
+      // `reason`, so that cause used to reach the entry-failure beacon as nothing at all. Carried on
+      // its OWN field: `err.reason` drives the toast copy and stays exactly as it is.
+      err.coverageReason = String((body && ((body.coverage && body.coverage.reason) || (body.meta && body.meta.reason))) || '');
       throw err;
     }
     const Pages = historyTranscriptPages();
@@ -215,12 +220,12 @@
     if (c._continuousSegment && index === 0) {
       if (body.newerCursor) return rebaseSeamPage(c, rows.length);
       landSeamPage(c, body, { reason: (opts && opts.reason) || 'refetch', cursor: opts && opts.cursor }); // D-19: a seam refresh lands as 'refresh'
-      if (direction === 'older' && (done || stuck)) c._transcriptDone = true;
+      if (direction === 'older' && (done || stuck)) { c._transcriptDone = true; if (stuck) c._transcriptModel.reachedStart = true; }
       return { ok: true, rows: rows.length, bytes: c._transcriptModel.bytes.get(index) || 0, shift: documentRows(c) - before };
     }
     const snap = hs.captureAnchor(c);
     Pages.insertPage(model, index, body);
-    if (direction === 'older' && (done || stuck)) c._transcriptDone = true;
+    if (direction === 'older' && (done || stuck)) { c._transcriptDone = true; if (stuck) model.reachedStart = true; }
     const target = hs.anchoredScrollTop(c, snap);
     const win = hs.neededRowWindow(c, target);
     // Eviction floor = the fetch window itself (viewport +/- 1 pane is inside it): a page the
@@ -1183,13 +1188,27 @@
   }
 
   // One retry timer at most (a no-op while pending).
+  // Clock-free tests (D-2/D-4, WP-6): the ladder's own progress is readable from the page -- `window.TerminalHistoryViewport.get(id)`
+  // is this `c` -- so a test waits on the loop's state instead of sleeping through a window at least as long as its period:
+  //   _seamRetryAttempts  -- monotone: +1 per step whose timer FIRED (the loop's attempt to re-ask). Counted before the ask is
+  //                          tried, so a step that skips the ask (a request is in flight, or the reader is gone) still counts as
+  //                          an attempt; `_seamRefreshes` counts the requests that actually started (null/undefined before the
+  //                          first landing that armed the ladder).
+  //   _seamRetryScheduled -- true while a step's timer is pending, false once it has fired or been cleared (also false/undefined
+  //                          with no ladder).
+  //   _seamRetryStopped   -- true once resetSeamFollow ran: a landing proved or overlapped the join (or the reader exited), so no
+  //                          further attempt will be made. Set false again only by a landing that is still `none` and re-arms it.
   function armSeamBehindRetry(c) {
     const step = Number(c._seamBehindStep) || 0;
     if (c._seamRetryTimer) return;
     c._seamBehindStep = Math.min(step + 1, SEAM_BEHIND_RETRY_MS.length);
+    c._seamRetryAttempts = Number(c._seamRetryAttempts) || 0; // a number from the first arm on, so a reader never has to tell 0 from "no ladder"
+    c._seamRetryScheduled = true; c._seamRetryStopped = false;
     /* deadline-exempt: bounded transcript-behind retry (SEAM_BEHIND_RETRY_MS: 1, 2, 4 s, then 10 s) that re-asks for page 0; cleared by a landing that proves or overlaps and on exit by resetSeamFollow; not a recovery/activation deadline */
     c._seamRetryTimer = setTimeout(() => {
       c._seamRetryTimer = null;
+      c._seamRetryScheduled = false;
+      c._seamRetryAttempts = (Number(c._seamRetryAttempts) || 0) + 1; // the step fired: this is the attempt, whatever the ask below does
       if (!c.active || !c._hs) return;
       if (!refreshSeamPage(c)) armSeamBehindRetry(c); // a request is in flight: look again next step
     }, SEAM_BEHIND_RETRY_MS[Math.min(step, SEAM_BEHIND_RETRY_MS.length - 1)]);
@@ -1199,6 +1218,8 @@
   function resetSeamFollow(c) {
     if (c._seamRetryTimer) { clearTimeout(c._seamRetryTimer); c._seamRetryTimer = null; }
     c._seamBehindStep = 0;
+    c._seamRetryScheduled = false;
+    c._seamRetryStopped = true; // D-18/WP-6: a landing that proved or overlapped, or an exit: the ladder is stopped for good
   }
 
   // D-17: a page 0 that still has a newer neighbour is not the transcript's tail (the file grew past
@@ -1344,6 +1365,9 @@
         const err = new Error(code);
         err.code = code;
         err.reason = (body && body.reason) || '';
+        // Same as applyTranscriptWindowBody: the server's own WHY (coverage.reason / meta.reason),
+        // kept on its own field so the entry-failure beacon can report it without touching the toast.
+        err.coverageReason = String((body && ((body.coverage && body.coverage.reason) || (body.meta && body.meta.reason))) || '');
         return failEntry(err);
       }
       if (!Array.isArray(body.rows) || body.rows.length === 0) {

package/template/coding-task-manager/public/js/history-painted-rows.js

@@ -79,6 +79,21 @@
     }
   }
 
+  // Clock-free tests (D-2/D-4, WP-6): the recorder's sample counter and the samples it is holding uncommitted travel next to
+  // `revision` on the frame's painted field, so a test waits on them instead of sleeping a window. `samples` is the recorder's
+  // monotone observe count (it moves on EVERY sample, including one that changes nothing). The frame carries the recorder's `hold`
+  // descriptor ({ kind, rows, top }: the samples it rejected and did not commit, null when it holds none -- the same fact as the
+  // recorder's boolean `held`, which does not travel on the wire); this store publishes it as `held`, its one store, so `held` here
+  // is unambiguously the descriptor. An older host (and today's /painted-rows route) sends neither: both read as null.
+  function observedOf(painted) {
+    const samples = Number.isSafeInteger(painted.samples) && painted.samples >= 0 ? painted.samples : null;
+    const h = painted.hold;
+    const held = h && typeof h === 'object'
+      ? { kind: typeof h.kind === 'string' ? h.kind : null, rows: Number.isSafeInteger(h.rows) && h.rows >= 0 ? h.rows : 0, top: Number.isSafeInteger(h.top) ? h.top : null }
+      : null;
+    return { samples, held };
+  }
+
   // `painted`: the validated frame field { epoch, top, pinned, floor, revision, breaks[, revisedFrom][, from, rows] }, or null (an older
   // host, a normal-buffer surface: no painted state; the rows already held stay until a state with another epoch or revision arrives).
   function noteFrame(session, painted) {
@@ -95,7 +110,7 @@
       else if (painted.revisedFrom !== undefined) dropFrom(store, painted.revisedFrom);
       else if (revision > store.revision) clearRows(store); // a keyframe or a missed delta: the rows revised are unknown
       store.revision = revision;
-      store.state = { epoch: painted.epoch, top: painted.top, pinned: painted.pinned, floor: painted.floor, revision, breaks: painted.breaks || [], below: Number.isSafeInteger(painted.below) && painted.below > 0 ? painted.below : 0 }; // R-F2: rows the app holds below its screen; an older host sends none, and that is 0
+      store.state = { epoch: painted.epoch, top: painted.top, pinned: painted.pinned, floor: painted.floor, revision, breaks: painted.breaks || [], below: Number.isSafeInteger(painted.below) && painted.below > 0 ? painted.below : 0, ...observedOf(painted) }; // R-F2: rows the app holds below its screen; an older host sends none, and that is 0
       if (Array.isArray(painted.rows) && Number.isSafeInteger(painted.from)) putRows(store, painted.from, painted.rows);
       trim(store);
     }
@@ -106,7 +121,7 @@
   function stateOf(sessionId) {
     const store = stores.get(String(sessionId));
     const st = store && store.state;
-    return st ? { epoch: st.epoch, top: st.top, pinned: st.pinned, floor: st.floor, revision: st.revision, breaks: st.breaks.map((b) => ({ at: b.at, reason: b.reason })), below: Number.isSafeInteger(st.below) ? st.below : 0 } : null;
+    return st ? { epoch: st.epoch, top: st.top, pinned: st.pinned, floor: st.floor, revision: st.revision, breaks: st.breaks.map((b) => ({ at: b.at, reason: b.reason })), below: Number.isSafeInteger(st.below) ? st.below : 0, samples: Number.isSafeInteger(st.samples) && st.samples >= 0 ? st.samples : null, held: st.held || null } : null;
   }
 
   // Rows [from, to) as stored; `undefined` where a row is not resident.

package/template/coding-task-manager/public/js/history-reader-park.js

@@ -178,7 +178,19 @@
     c._renderTranscript();
     const rh = Number(c.rowHeight) > 0 ? Number(c.rowHeight) : 17;
     const offset = Pages.offsetOfPage(c._transcriptModel, index) + (Number(bookmark.rowOffsetInPage) || 0);
-    if (c.scrollEl) c.scrollEl.scrollTop = offset * rh; // WP-2: one coordinate for every source (the native scroller included)
+    // reader-scroll-write beacon: a resume that lands more than one pane from where the reader was is a
+    // movement nobody scrolled, so it names itself (`resume`). The write is the same one it was.
+    if (c.scrollEl) {
+      const target = offset * rh; // WP-2: one coordinate for every source (the native scroller included)
+      const hs = scroller(); // resolved at call time, like resumePaintedRow's
+      const before = Number(c.scrollEl.scrollTop) || 0;
+      c.scrollEl.scrollTop = target;
+      const after = Number(c.scrollEl.scrollTop) || 0;
+      if (c._hs) c._hs.lastTop = after;
+      if (hs && typeof hs.noteBigScroll === 'function' && Math.abs(after - before) > (Number(c.scrollEl.clientHeight) || 0)) {
+        hs.noteBigScroll(c, 'resume', before, after, target);
+      }
+    }
     return true;
   }
 

package/template/coding-task-manager/public/js/history-scroller.js

@@ -126,10 +126,7 @@
   function setSpacerHeightAnchored(c, nextHeightPx, deltaAbovePx) {
     if (c && c.spacerEl) c.spacerEl.style.height = (Number(nextHeightPx) || 0) + 'px';
     const delta = Number(deltaAbovePx) || 0;
-    if (delta && c && c.scrollEl) {
-      c.scrollEl.scrollTop = (Number(c.scrollEl.scrollTop) || 0) + delta;
-      if (c._hs) c._hs.lastTop = Number(c.scrollEl.scrollTop) || 0;
-    }
+    if (delta && c && c.scrollEl) writeScrollTop(c, 'spacer', (Number(c.scrollEl.scrollTop) || 0) + delta);
   }
 
   // D-3 (unified-scrollbar track wheel, keys): deltaMode 0 = px, 1 = lines (x row height),
@@ -144,11 +141,166 @@
     const scroller = c && c.scrollEl;
     if (!scroller) return false;
     const top = deltaPx(c, deltaY, deltaMode);
+    const before = Number(scroller.scrollTop) || 0;
     if (typeof scroller.scrollBy === 'function') scroller.scrollBy({ top });
-    else scroller.scrollTop = (Number(scroller.scrollTop) || 0) + top;
+    else scroller.scrollTop = before + top;
+    const after = Number(scroller.scrollTop) || 0;
+    noteBigScrollIfPane(c, 'scrollBy', before, after, after); // scrollBy clamps the delta itself: there is no separate target to report
     return true;
   }
 
+  // ---------------------------------------------------------------------------
+  // reader-scroll-write (2026-10-25 incident: a light wheel-up jumped the reader ~5,800 rows to the
+  // top of its document and the D-2 chain then fetched 11 pages; telemetry named no write). INSTRUMENT
+  // ONLY: every write below is the same write it was before, the only additions are the two beacons
+  // `history-reader-scroll-write` (a movement bigger than one pane, with its site) and
+  // `history-reader-chain-advance` (a burst of chain advances). Both coalesce into bounded integers --
+  // no transcript text, no URLs, no cursors -- and every failure is swallowed: nothing in the scroll,
+  // anchor, fetch or park path reads any of this.
+  // ---------------------------------------------------------------------------
+  const SCROLL_WRITE_EVENT = 'history-reader-scroll-write';
+  const CHAIN_ADVANCE_EVENT = 'history-reader-chain-advance';
+  /* deadline-exempt: the scroll-write beacon's fixed coalescing window (one row per incident burst), not a recovery/activation deadline */
+  const SCROLL_WRITE_COALESCE_MS = 1100;
+  const CHAIN_WINDOW_MS = 1000; // a chain-advance burst is this many advances inside this sliding window
+  const CHAIN_BURST = 4;
+  const CHAIN_STAMP_CAP = 16;
+  const SCROLL_WRITE_ENTRY_CAP = 4; // the first four entries name the burst; the rest are counted
+  const SCROLL_WRITE_ENTRY_CHARS = 40; // the server keeps 40 chars per entry
+  const TARGET_EPSILON_PX = 1; // above this the browser did not land where it was told (it clamped)
+
+  // The ONE write path: the same scrollTop assignment every instrumented site made before, plus the
+  // measurement that names it. `target` is what was asked for, the return value what the browser
+  // clamped to (a clamped write is itself the interesting case).
+  function writeScrollTop(c, site, target) {
+    const scroller = c && c.scrollEl;
+    if (!scroller) return 0;
+    const before = Number(scroller.scrollTop) || 0;
+    scroller.scrollTop = target;
+    const after = Number(scroller.scrollTop) || 0;
+    if (c._hs) c._hs.lastTop = after; // programmatic: never counted as travel
+    noteBigScrollIfPane(c, site, before, after, target);
+    return after;
+  }
+  function noteBigScrollIfPane(c, site, before, after, target) {
+    const scroller = c && c.scrollEl;
+    if (!scroller) return;
+    if (Math.abs(Number(after) - Number(before)) > (Number(scroller.clientHeight) || 0)) noteBigScroll(c, site, before, after, target);
+  }
+
+  function scrollWriteState(c) {
+    if (!c._bigScrollDiag) c._bigScrollDiag = { count: 0, entries: [], firstSite: '', lastSite: '', before: 0, after: 0, timer: null };
+    return c._bigScrollDiag;
+  }
+  // `tag.class` (first class only) of whatever holds the keyboard: the one hint a `native` movement cannot
+  // otherwise carry. Never an id, a value or any text the element holds.
+  function activeElementTagClass() {
+    const el = typeof document !== 'undefined' ? document.activeElement : null;
+    if (!el) return '';
+    const tag = String(el.tagName || '').toLowerCase();
+    if (!tag) return '';
+    const cls = (typeof el.className === 'string' ? el.className.trim().split(/\s+/)[0] : '') || '';
+    return '@' + (cls ? tag + '.' + cls : tag);
+  }
+
+  // Coalesced: the first 4 entries (in order) plus the count and the geometry that places them, one
+  // beacon per episode. Called per big write -- never per scroll event.
+  function noteBigScroll(c, site, before, after, target) {
+    if (!c || typeof c.sendDiag !== 'function') return; // no diag channel: nothing to record, and no timer to arm for it
+    try {
+      const state = scrollWriteState(c);
+      const b = Math.round(Number(before) || 0);
+      const a = Math.round(Number(after) || 0);
+      let entry = site + ':' + b + '>' + a;
+      if (Math.abs((Number(target) || 0) - (Number(after) || 0)) > TARGET_EPSILON_PX) entry += '(t=' + Math.round(Number(target) || 0) + ')';
+      if (site === 'native') entry += activeElementTagClass();
+      if (state.count === 0) { state.before = b; state.firstSite = site; }
+      state.count += 1;
+      state.after = a;
+      state.lastSite = site;
+      if (state.entries.length < SCROLL_WRITE_ENTRY_CAP) state.entries.push(entry.slice(0, SCROLL_WRITE_ENTRY_CHARS));
+      if (state.timer == null) state.timer = setTimeout(function () { flushBigScroll(c); }, SCROLL_WRITE_COALESCE_MS);
+    } catch { /* expected: diag is best-effort */ }
+  }
+
+  // The geometry every beacon carries, read once at flush time (`_hs` is gone after a park, so restPx/
+  // spacerPx/sinceMountMs read 0 then -- the entries still name the movement).
+  function scrollDiagFacts(c) {
+    const hint = c && c._hs;
+    const model = c && c._transcriptModel;
+    const Pages = historyTranscriptPages();
+    const scroller = c && c.scrollEl;
+    let totalRows = 0;
+    let oldest = -1;
+    if (Pages && model) {
+      totalRows = Math.round(Number(Pages.totalRows(model, { separator: true })) || 0);
+      const known = Pages.oldestKnownIndex(model);
+      if (known !== null && known !== undefined) oldest = known;
+    }
+    return {
+      scrollTopPx: Math.round(Number(scroller && scroller.scrollTop) || 0),
+      panePx: Math.round(Number(scroller && scroller.clientHeight) || 0),
+      restPx: hint ? Math.round(restOf(c)) : 0,
+      spacerPx: hint ? Math.round(spacerHeightOf(c)) : 0,
+      totalRows,
+      oldestPage: oldest,
+      residentPages: model && model.pages ? model.pages.size : 0,
+      sinceMountMs: hint && Number(hint.mountedAt) ? Math.max(0, Math.round(Date.now() - Number(hint.mountedAt))) : 0,
+    };
+  }
+
+  // Sends the one beacon for the episode just ended and clears it (synchronously, from unmountScroller
+  // too, so a jump right before a park/exit is not lost). The state is cleared BEFORE the send: a
+  // re-entrant write from inside sendDiag starts a fresh episode rather than extending this one.
+  function flushBigScroll(c) {
+    const state = c && c._bigScrollDiag;
+    if (!state) return;
+    if (state.timer != null) clearTimeout(state.timer);
+    c._bigScrollDiag = null;
+    if (typeof c.sendDiag !== 'function') return;
+    try {
+      c.sendDiag(Object.assign({
+        count: state.count, entries: state.entries, firstSite: state.firstSite, lastSite: state.lastSite,
+        before: state.before, after: state.after,
+        chainAdv1s: chainAdvancesWithin(c, Date.now()), // was the D-2 chain running while the viewport moved?
+      }, scrollDiagFacts(c)), SCROLL_WRITE_EVENT);
+    } catch { /* expected: diag is best-effort */ }
+  }
+
+  // The chain advances inside the last CHAIN_WINDOW_MS, as of `nowMs` (pure; Beacon 1 reads it).
+  function chainAdvancesWithin(c, nowMs) {
+    const stamps = c && Array.isArray(c._chainAdvanceAt) ? c._chainAdvanceAt : [];
+    const now = Number(nowMs) || 0;
+    let count = 0;
+    for (let i = stamps.length - 1; i >= 0; i -= 1) {
+      if (now - (Number(stamps[i]) || 0) > CHAIN_WINDOW_MS) break;
+      count += 1;
+    }
+    return count;
+  }
+
+  // Beacon 2: one chain advance started a fetch (the stamps are a sliding window, so an old burst never
+  // inflates a new one). The fourth inside the window reports once; the flag clears when the window has
+  // fully aged out, so a later burst reports again. No change to WHEN the chain advances.
+  function noteChainAdvance(c, where) {
+    if (!c) return;
+    try {
+      const now = Date.now();
+      const kept = (Array.isArray(c._chainAdvanceAt) ? c._chainAdvanceAt : []).filter((at) => now - (Number(at) || 0) <= CHAIN_WINDOW_MS);
+      if (kept.length === 0) c._chainAdvanceBurstSent = false; // the previous burst's window has cleared
+      kept.push(now);
+      c._chainAdvanceAt = kept.slice(-CHAIN_STAMP_CAP);
+      if (kept.length < CHAIN_BURST || c._chainAdvanceBurstSent || typeof c.sendDiag !== 'function') return;
+      c._chainAdvanceBurstSent = true; // set before the send: a throwing sendDiag must not re-report
+      c.sendDiag(Object.assign({
+        count: kept.length,
+        topRow: Math.round(Number(where && where.topRow) || 0),
+        oldestPage: where && where.oldestPage !== null && where.oldestPage !== undefined ? where.oldestPage : -1,
+        oldestFrom: Math.round(Number(where && where.oldestFrom) || 0),
+      }, scrollDiagFacts(c)), CHAIN_ADVANCE_EVENT);
+    } catch { /* expected: diag is best-effort */ }
+  }
+
   function liveRowsOf(c) {
     const live = c && c.getLive && c.getLive();
     return Math.max(1, Number(live && live.term && live.term.rows) || 1);
@@ -208,8 +360,9 @@
   function applyAnchor(c, target) {
     const scroller = c && c.scrollEl;
     if (!scroller) return false;
-    if (Math.abs((Number(scroller.scrollTop) || 0) - target) > 0.01) scroller.scrollTop = target;
-    if (c._hs) c._hs.lastTop = Number(scroller.scrollTop) || 0; // programmatic: never counted as travel
+    // The 0.01 px guard is the write-skip that was always here: a sub-pixel "move" is not a write at all.
+    if (Math.abs((Number(scroller.scrollTop) || 0) - target) > 0.01) writeScrollTop(c, 'anchor', target);
+    else if (c._hs) c._hs.lastTop = Number(scroller.scrollTop) || 0; // programmatic: never counted as travel
     return true;
   }
 
@@ -304,6 +457,24 @@
       seam.fetchTranscriptPage(c, index, plan.cursor, plan.direction, { attempt: 1, maxRows: plan.maxRows });
       slots -= 1; started += 1;
     }
+    // D-2: the window lies above what the chain can serve (`pagesForRows` named only "virtual" indices past
+    // `oldest + 1`, whose plan is null by construction; nothing landed, so no scroll event follows either --
+    // the anchor holds the viewport's distance invariant). Advance the chain one page toward the window; each
+    // landing schedules the next frame, and `planPageChain` answers null once reachedStart/_transcriptDone is set.
+    if (started === 0 && slots > 0) {
+      const oldest = Pages.oldestKnownIndex(model);
+      const range = oldest === null ? null : Pages.rangeOfPage(model, oldest);
+      const next = oldest === null ? null : oldest + 1;
+      if (range && win.topRow < range.from && !model.pages.has(next) && !c._transcriptAborters.has(next) && !seam.pageRetryPending(c, next)) {
+        const plan = seam.planPageFetch(c, next);
+        if (plan) {
+          seam.clearFailedPage(c, next);
+          seam.fetchTranscriptPage(c, next, plan.cursor, plan.direction, { attempt: 1, maxRows: plan.maxRows });
+          noteChainAdvance(c, { topRow: win.topRow, oldestPage: oldest, oldestFrom: range.from }); // the burst beacon; the advance itself is unchanged
+          slots -= 1; started += 1;
+        }
+      }
+    }
     return started + fetchPaintedHoles(c, win, viewTop, slots);
   }
 
@@ -457,7 +628,7 @@
     const rh = rowHeightOf(c);
     if (e.key === 'Home') {
       e.preventDefault();
-      if (typeof scroller.scrollTo === 'function') scroller.scrollTo({ top: 0 }); else scroller.scrollTop = 0;
+      writeScrollTop(c, 'home', 0); // the reader spells Home the same way it wrote it before (`scrollTo({top:0})` on a scroller whose scroll-behavior is the default `auto`)
       return true;
     }
     const by = { PageUp: -page, PageDown: page, ArrowUp: -rh, ArrowDown: rh }[e.key];
@@ -543,6 +714,8 @@
     };
     c._hs = state;
     c._skeletonMs = 0; c._skelSince = 0; c._travelPx = 0; c._winPx = null; c._lastFetchTop = undefined; c._seamRefreshes = 0; // WP-3 D-15 / D-20 counters, per open
+    c._bigScrollDiag = null; c._chainAdvanceAt = []; c._chainAdvanceBurstSent = false; // the two beacons' state is per open
+    state.mountedAt = Date.now(); // sinceMountMs places a jump in the open's own timeline
     c._seamBehindStep = 0; // D-19: the transcript-behind retry ladder, per open
     try {
       const viewportModuleRef = viewportModule();
@@ -594,6 +767,9 @@
       state.onScroll = function onReaderScroll() {
         const top = Number(scroller.scrollTop) || 0;
         c._travelPx = (Number(c._travelPx) || 0) + Math.abs(top - state.lastTop); // D-15 travelPx
+        // Every instrumented write sets lastTop itself, so a movement past one pane here is one none of
+        // them made: the browser moved the scroller (wheel, focus, CSS anchoring, a reflow).
+        noteBigScrollIfPane(c, 'native', state.lastTop, top, top);
         state.lastTop = top;
         if (isAtRest(c)) { exitReader(c, 'scroll'); return; } // D-5: the only scroll-driven exit
         syncSkeleton(c);
@@ -615,7 +791,7 @@
           paintSkeletonTile(c);
           applyClip(c); // the pinned rows are a count of rows: their px follow the row height
           c._renderTranscript();
-          scroller.scrollTop = next.scrollTop;
+          writeScrollTop(c, 'remeasure', next.scrollTop);
         });
         c.ro.observe(scroller);
       }
@@ -632,6 +808,7 @@
   function unmountScroller(c) {
     const state = c && c._hs;
     if (!state) return false;
+    flushBigScroll(c); // a jump right before a park/exit is not lost; the episode's timer is cleared here, never left pending
     if (c._skelSince) { c._skeletonMs = (Number(c._skeletonMs) || 0) + Date.now() - c._skelSince; c._skelSince = 0; } // D-15: kept on `c` for the exit beacon
     c._hs = null;
     cancelFetchAhead(c);
@@ -657,6 +834,7 @@
   return Object.freeze({
     ensureTermScroller, mountScroller, unmountScroller, isMounted, isMountedFor, isAtRest, clipPx, restOf, applyClip, commitPainted,
     setSpacerHeightAnchored, scrollByPx, neededRowWindow, scheduleFetchAhead, scheduleRender, cancelRender, scheduleFrame, cancelFrame, RENDER_FALLBACK_MS, runFetchAhead, liveWheelVeto,
+    noteBigScroll, chainAdvancesWithin, // reader-scroll-write beacons: the park/resume path and the tests call these
     handleKeydown, typedKeyData, leaveAndType, captureAnchor, anchoredScrollTop, applyAnchor, refreshLiveRows, syncSkeleton, skeletonMs, REST_EPSILON, MAX_IN_FLIGHT,
   });
 });

package/template/coding-task-manager/public/js/history-transcript-pages.js

@@ -313,10 +313,11 @@
     return Math.min(MAX_ESTIMATE_ROWS, Math.max(live, est));
   }
 
+  // D-8/R-2 (WP-2): the OLDEST known page index in `rowCounts` (index k+1 is older than k), resident or not, or null while nothing is known.
+  const oldestKnownIndex = (model) => { let oldest = null; for (const index of model.rowCounts.keys()) if (oldest === null || index > oldest) oldest = index; return oldest; };
   function _estimate(model, liveRows) {
     if (model.rowCounts.size === 0 || model.reachedStart) return 0;
-    let oldest = null;
-    for (const index of model.rowCounts.keys()) if (oldest === null || index > oldest) oldest = index;
+    const oldest = oldestKnownIndex(model);
     const cursor = model.cursors.get(oldest);
     if (!cursor || cursor.olderCursor == null) return 0;
     // Pages of the same source chunk report identical (start, end): count each distinct byte range
@@ -354,8 +355,7 @@
   function _layout(model, liveRows) {
     const live = Math.max(1, Math.floor(Number(liveRows) || Number(model.liveRows) || 1));
     const est = _estimate(model, live);
-    let oldest = null;
-    for (const index of model.rowCounts.keys()) if (oldest === null || index > oldest) oldest = index;
+    const oldest = oldestKnownIndex(model);
     const entries = [];
     const byIndex = new Map();
     let cursor = est;
@@ -495,7 +495,7 @@
   }
 
   return Object.freeze({
-    createModel,
+    createModel, oldestKnownIndex,
     promptAtOrAbove,
     insertPage,
     pageKinds,