webbee 0.3.17__tar.gz → 0.3.18__tar.gz

{webbee-0.3.17 → webbee-0.3.18}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.3.18
+
+The adaptive wave: the terminal finally behaves like a real app.
+
+- Stretch or shrink the window and the WHOLE transcript re-wraps live to the
+  new size — history included, splash re-centered, nothing clipped, no dead
+  margins. Panels, the input box and text truncations now scale as
+  proportions of your screen, not fixed character counts.
+- Select text with the mouse and drag past the edge — the transcript
+  auto-scrolls under your selection, keeps selecting while you hold at the
+  edge, and finishes the copy even if you release outside the pane. Scrolling
+  mid-selection no longer corrupts what you copy, and a lost release can
+  never hijack your next click or your clipboard.
+
 ## 0.3.17
 
 Bulletproof core (W1): a marathon can no longer be killed by transport, the

{webbee-0.3.17 → webbee-0.3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.17
+Version: 0.3.18
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.3.17 → webbee-0.3.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.17"
+version = "0.3.18"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.18/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.18"

webbee-0.3.18/src/webbee/output_pane.py

@@ -0,0 +1,347 @@
+"""The full-screen dock's scrollable, colored output region. Rich renders the
+full transcript into a StringIO as ANSI; the pane VIRTUALIZES — the
+FormattedTextControl is fed ONLY the currently-visible slice of lines, so
+every frame costs O(viewport), not O(session). Wheel / PageUp move `_offset`;
+left-drag copies to the local clipboard (`webbee.clipboard`), OSC 52 fallback."""
+
+_MAX_RECORDS = 4000     # RecordingConsole ring bound (W2 front-2: replay material for reflow)
+
+
+class OutputPane:
+    def __init__(self, width: int = 100) -> None:
+        import io
+        from collections import deque
+
+        from prompt_toolkit.formatted_text import ANSI
+        from prompt_toolkit.layout.containers import Window
+        from prompt_toolkit.layout.controls import FormattedTextControl
+        from prompt_toolkit.mouse_events import MouseEventType, MouseButton
+        from rich.console import Console
+
+        self._io = io.StringIO()
+        pane = self
+        pane_records: deque = deque(maxlen=_MAX_RECORDS)
+
+        class _RecordingConsole(Console):
+            """Captures every printed renderable so a width change can REPLAY
+            the transcript (old pane kept only baked ANSI, which can't
+            re-wrap). Bounded ring: past 4000 records, only the tail replays."""
+
+            def print(self, *objects, **kw):        # noqa: A003
+                if getattr(pane, "_replaying", False):  # replay latch: never re-record
+                    return super().print(*objects, **kw)
+                evicting = len(pane_records) == pane_records.maxlen
+                pane_records.append((objects, kw))
+                pane._all_lines()                    # sync the W1 cache to the pre-write pos
+                pos = pane._io.tell()
+                result = super().print(*objects, **kw)
+                pane._io.seek(pos)
+                delta = pane._io.read()              # leaves position at EOF again
+                if evicting and pane._record_lines:  # stay in lockstep with the deque's own drop
+                    evicted_span = pane._record_lines[0]   # capture BEFORE deleting
+                    del pane._record_lines[0]
+                    pane._ring_base_lines += evicted_span  # the evicted lines don't vanish —
+                                                            # they become pre-ring buffer content
+                pane._record_lines.append(delta.count("\n"))
+                return result
+
+            def clear(self, *a, **kw):
+                pane_records.clear()
+                pane._reset_buffer()                # StringIO + caches reset (Task 3 builds on it)
+
+        self._records = pane_records
+        self._record_lines: list = []      # per-record NEW-line count, prefix-summable (reflow.py)
+        self._ring_base_lines = 0          # buffer content lines BEFORE ring record 0 (deque
+                                            # eviction + trims) — invariant: len(_all_lines()) ==
+                                            # 1 + _ring_base_lines + sum(_record_lines)
+        self._replaying = False            # True while a width-reflow replay is in flight
+        self.console = _RecordingConsole(file=self._io, force_terminal=True,
+                                         color_system="truecolor", width=width,
+                                         highlight=False)
+        self._ANSI = ANSI
+        self._lines_cache = (0, [""])      # (write-pos, split-lines) — memoize the split
+        self._offset = 0                   # index of the top visible line
+        self._view_h = 20                  # viewport height (updated from render_info)
+        self._follow = True                # stick to the tail unless the user scrolled up
+        self._sel = None                   # (abs_start, abs_end) during a drag → live highlight
+        self._edge_drag = 0                # +1/-1 while dragging at the bottom/top edge, else 0
+        self._edge_ticks = 0                # consecutive edge_tick()s since the last drag MOUSE_MOVE
+        self._plain_cache = (0, [""])      # (write-pos, ANSI-stripped lines) for select/highlight
+        self.copy_flash = ""               # transient toolbar note after a copy
+        self._flash_until = 0.0
+
+        # The mouse-selection control lives in selection.py (file-ceiling
+        # headroom) — a factory closed over this pane, not a shared class.
+        from webbee.selection import make_select_control
+        _SelectControl = make_select_control(pane, FormattedTextControl, MouseEventType, MouseButton)
+        self.control = _SelectControl(text=self._formatted, focusable=False, show_cursor=False)
+        self.window = Window(content=self.control, wrap_lines=False, always_hide_cursor=True)
+
+    # ---- virtualized render ---------------------------------------------
+    def _all_lines(self):
+        # Cache keyed on the stream WRITE POSITION (O(1)); a hit returns the
+        # list as-is, a miss reads only the DELTA and extends it IN PLACE —
+        # never a full getvalue()+re-split (that was O(session) per print).
+        pos = self._io.tell()
+        cpos, lines = self._lines_cache
+        if cpos == pos:
+            return lines
+        if isinstance(cpos, int) and 0 <= cpos < pos:
+            self._io.seek(cpos)
+            delta = self._io.read()          # leaves position at EOF (== pos)
+            parts = delta.split("\n")
+            lines[-1] += parts[0]
+            lines.extend(parts[1:])
+        else:
+            lines = self._io.getvalue().split("\n")
+        self._lines_cache = (pos, lines)
+        return lines
+
+    def _plain_lines(self):
+        import re
+        pos = self._io.tell()
+        cpos, lines = self._plain_cache
+        if cpos == pos:
+            return lines
+        if isinstance(cpos, int) and 0 <= cpos < pos:
+            self._io.seek(cpos)
+            delta = re.sub(r"\x1b\[[0-9;]*m", "", self._io.read())
+            parts = delta.split("\n")
+            lines[-1] += parts[0]
+            lines.extend(parts[1:])
+        else:
+            lines = re.sub(r"\x1b\[[0-9;]*m", "", self._io.getvalue()).split("\n")
+        self._plain_cache = (pos, lines)
+        return lines
+
+    def _norm_sel(self):
+        (a, b) = self._sel
+        return (a, b) if a <= b else (b, a)
+
+    def _formatted(self):
+        ri = self.window.render_info
+        if ri is not None and ri.window_height:
+            self._view_h = ri.window_height
+        lines = self._all_lines()
+        h = max(1, self._view_h)
+        off = max(0, min(self._offset, max(0, len(lines) - h)))
+        self._offset = off
+        visible = lines[off:off + h]
+        if self._sel is None:
+            return self._ANSI("\n".join(visible))
+        # A drag is in progress — overlay reverse-video on the selected columns.
+        (y1, x1), (y2, x2) = self._norm_sel()
+        plain = self._plain_lines()
+        out = []
+        for vi, aln in enumerate(range(off, off + len(visible))):
+            if y1 <= aln <= y2 and aln < len(plain):
+                ln = plain[aln]
+                a = max(0, min(x1 if aln == y1 else 0, len(ln)))
+                b = max(-1, min(x2 if aln == y2 else len(ln) - 1, len(ln) - 1))
+                out.append(ln[:a] + "\x1b[7m" + ln[a:b + 1] + "\x1b[0m" + ln[b + 1:]
+                           if b >= a else ln)
+            else:
+                out.append(visible[vi])
+        return self._ANSI("\n".join(out))
+
+    def scroll(self, delta: int) -> None:
+        lines = self._all_lines()
+        max_off = max(0, len(lines) - max(1, self._view_h))
+        self._offset = max(0, min(self._offset + delta, max_off))
+        self._follow = self._offset >= max_off   # re-arm tail-follow once back at bottom
+        self._invalidate()
+
+    def edge_tick(self) -> None:
+        """Called by tui's `_ticker` every 0.25s: while the pointer sits at a
+        viewport edge during a drag, keep scrolling and keep growing the
+        selection — no MOUSE_MOVE arrives while the mouse is stationary, so
+        without this the drag would freeze at the edge instead of eating
+        past the screen. No-op unless a drag is armed AND still active.
+
+        Runaway guard: `_edge_ticks` counts consecutive ticks since the last
+        fresh drag MOUSE_MOVE (reset there, in selection.py) — a pointer
+        genuinely parked at the edge for ~10s (40 ticks) stops the auto-scroll
+        (the selection itself STAYS armed; a MOUSE_DOWN or forward_mouse
+        hygiene reset is what actually clears it) rather than eating the
+        whole scrollback hands-free forever."""
+        if self._edge_drag == 0 or self.control._down_abs is None:
+            return
+        self._edge_ticks += 1
+        if self._edge_ticks > 40:
+            self._edge_drag = 0
+            return
+        self.scroll(3 * self._edge_drag)
+        start, end = self._sel
+        end_x = end[1]                       # keep the column from the current _sel end
+        row = self._offset + self._view_h - 1 if self._edge_drag > 0 else self._offset
+        self._sel = (start, (row, end_x))
+        self._invalidate()
+
+    def notify(self) -> None:
+        """After each sink print: follow the tail unless the user scrolled up."""
+        self._trim()
+        lines = self._all_lines()
+        max_off = max(0, len(lines) - max(1, self._view_h))
+        self._offset = max_off if self._follow else min(self._offset, max_off)
+        self._invalidate()
+
+    def _record_at_line(self, line: int) -> int:
+        """Record owning absolute content line `line` (reflow.py prefix sum
+        over the RING's own spans — `line` is offset by `_ring_base_lines`
+        first, since the ring's record 0 starts only after the base)."""
+        from webbee.reflow import record_at_line
+        return record_at_line(self._record_lines, max(0, line - self._ring_base_lines))
+
+    def reflow(self, new_width: int) -> None:
+        """Replay the retained ring at a new width (true reflow — old ANSI
+        can't re-wrap), anchored by RECORD not line index: a re-wrap changes
+        how many lines a record spans, so only the record stays stable.
+        Lines BEFORE the ring's first record (`_ring_base_lines` — deque
+        eviction + trims) are never in the ring, so they can't be replayed:
+        they're carried over VERBATIM at their OLD (already-baked) width —
+        the one concession this makes — while the ring itself genuinely
+        re-wraps at `new_width`."""
+        from rich.console import Console
+        from webbee.reflow import anchor_offset
+        if new_width == self.console.width or new_width < 10:
+            return
+        follow = self._follow
+        base = self._ring_base_lines
+        old_offset = self._offset
+        pre_ring = (not follow) and old_offset < base   # top-visible line was pre-ring content
+        top_record = 0 if follow else self._record_at_line(old_offset)
+        pre = self._all_lines()[:base] if base else []  # baked ANSI at the OLD width
+        self._sel = None                     # a mid-drag resize aborts the drag honestly
+        self._edge_drag = 0
+        self.control._down = None
+        self.control._down_abs = None
+        self.console.width = new_width
+        self._reset_buffer()
+        if pre:
+            self._io.write("\n".join(pre) + "\n")   # pre-ring scrollback survives, unwrapped
+        self._ring_base_lines = base             # the COUNT never changes, only the ring re-wraps
+        spans: list = []
+        self._replaying = True
+        try:
+            for objects, kw in list(self._records):
+                before = len(self._all_lines())
+                Console.print(self.console, *objects, **kw)   # bypass the recording override
+                spans.append(len(self._all_lines()) - before)
+        finally:
+            self._replaying = False
+        self._record_lines = spans
+        max_off = max(0, len(self._all_lines()) - max(1, self._view_h))
+        if pre_ring:
+            self._offset = min(old_offset, max_off)   # pre-ring lines don't re-wrap — no anchor math
+        else:
+            self._offset = anchor_offset(spans, top_record, max_off, follow, base)
+        self._follow = follow and self._offset >= max_off
+        self._invalidate()
+
+    def _invalidate(self) -> None:
+        try:
+            from prompt_toolkit.application import get_app_or_none
+            app = get_app_or_none()
+            if app is not None:
+                app.invalidate()
+        except Exception:
+            pass
+
+    def _trim(self, max_lines: int = 20000, keep: int = 15000) -> None:
+        # Hysteresis: only trim past max_lines, cut down to ~`keep`
+        # (amortized) — but NEVER split a ring record. The cut consumes the
+        # BASE (pre-ring content — already unreplayable, safe to drop
+        # outright) first, then only WHOLE leading ring records; the actual
+        # cut moves UP to the nearest record boundary, so a post-trim reflow
+        # can never resurrect a partially-trimmed record from the ring.
+        import io
+        lines = self._all_lines()
+        if len(lines) <= max_lines:
+            return
+        dropped = len(lines) - keep
+        base = self._ring_base_lines
+        take = min(base, dropped)                         # consume the base first
+        from webbee.reflow import records_to_drop
+        n_drop, lines_covered = records_to_drop(self._record_lines, dropped - take)
+        actual_dropped = take + lines_covered              # the REAL cut — may be < dropped
+        s = "\n".join(lines[actual_dropped:])
+        self._io = io.StringIO()
+        self._io.write(s)
+        self.console.file = self._io
+        self._lines_cache = (0, [""])
+        self._plain_cache = (0, [""])
+        self._ring_base_lines = base - take
+        self._offset = max(0, self._offset - actual_dropped)   # viewport anchored to the same content
+        if self.control._down_abs is not None:              # an armed drag stays on the same CONTENT
+            y, x = self.control._down_abs
+            self.control._down_abs = (max(0, y - actual_dropped), x)
+        if self._sel is not None:
+            (y1, x1), (y2, x2) = self._sel
+            self._sel = ((max(0, y1 - actual_dropped), x1), (max(0, y2 - actual_dropped), x2))
+        for _ in range(n_drop):
+            self._records.popleft()
+        del self._record_lines[:n_drop]
+
+    def _reset_buffer(self) -> None:
+        """`/clear` and `reflow()` both wipe the transcript to empty — the
+        pane owns the alt screen, so an emptied buffer IS the cleared state.
+        `reflow()` rebuilds `_record_lines` (and restores `_ring_base_lines`
+        — the COUNT survives a reflow, only `/clear` truly zeroes it) right
+        after calling this."""
+        import io
+        self._io = io.StringIO()
+        self.console.file = self._io
+        self._lines_cache = (0, [""])
+        self._plain_cache = (0, [""])
+        self._record_lines = []
+        self._ring_base_lines = 0
+        self._offset = 0
+
+    def dump(self) -> str:
+        """Full session transcript (ANSI), printed to real stdout on exit."""
+        return self._io.getvalue()
+
+    # ---- copy-on-select --------------------------------------------------
+    def _selected_text(self, start, end) -> str:
+        """Plain text (ANSI stripped) covered by a drag. start/end are
+        ABSOLUTE (line, col) pairs already resolved by the caller — no offset conversion happens here."""
+        lines = self._plain_lines()
+        p1, p2 = (start, end) if start <= end else (end, start)
+        (y1, x1), (y2, x2) = p1, p2
+        n = len(lines)
+        if not (0 <= y1 < n):
+            return ""
+        y2 = min(y2, n - 1)
+        if y1 == y2:
+            return lines[y1][x1:x2 + 1]
+        out = [lines[y1][x1:]]
+        out.extend(lines[y1 + 1:y2])
+        out.append(lines[y2][:x2 + 1])
+        return "\n".join(out)
+
+    def _copy_selection(self, start_abs, end_abs) -> None:
+        # start_abs/end_abs: ABSOLUTE (line, col) pairs — see _selected_text.
+        import time as _t
+        from webbee.clipboard import copy_to_clipboard
+        text = self._selected_text(start_abs, end_abs)
+        if not text.strip():
+            return
+        self.copy_flash = copy_to_clipboard(text)  # local clipboard first, OSC 52 fallback
+        self._flash_until = _t.monotonic() + 1.8
+        self.notify()
+
+    def flash(self) -> str:
+        """The transient 'copied' note, while still fresh (else empty)."""
+        import time as _t
+        return self.copy_flash if _t.monotonic() < self._flash_until else ""
+
+    # ---- W2 Task 8: selection capture past the pane's own Window --------
+    def forward_mouse(self, ev) -> bool:
+        """Public seam neighbor windows call FIRST (via `tui._forwarding` /
+        the queue+todo panels' `forward=` param) so a drag armed inside this
+        pane can still be extended/completed once the pointer — and thus
+        prompt_toolkit's per-position mouse routing — has moved onto them.
+        True = consumed (a drag was armed); False = untouched, caller falls
+        through to its own handling. Full behavior in selection.forward_mouse."""
+        from webbee.selection import forward_mouse as _forward_mouse
+        return _forward_mouse(self, ev)

{webbee-0.3.17 → webbee-0.3.18}/src/webbee/queue_panel.py

@@ -24,15 +24,17 @@ def one_line(text: str, width: int) -> str:
     return t
 
 
-def queue_height(pending, remote=None, collapsed=False) -> int:
+def queue_height(pending, remote=None, collapsed=False, max_items=QP_MAX_ITEMS) -> int:
     """PURE. Rows the panel needs: 1 header + one per SHOWN item + one
-    `… +K more` row when a queue is deeper than QP_MAX_ITEMS (each of the
+    `… +K more` row when a queue is deeper than `max_items` (each of the
     two sections — remote rows and local rows — caps independently). 0 when
     both are empty (the ConditionalContainer hides the panel then anyway).
     `collapsed=True` (Task 11 click-to-collapse) always costs exactly 1 row
-    when there's data — screen space back on demand. The cap keeps the
-    output pane dominant on small terminals; the toolbar's `⋯N queued`
-    segment stays the truth-teller for the full depth."""
+    when there's data — screen space back on demand. `max_items` defaults to
+    QP_MAX_ITEMS but the dock overrides it with a LIVE, terminal-proportional
+    cap (sizing.panel_cap) so a huge screen shows more and a tiny one shows
+    less — the toolbar's `⋯N queued` segment stays the truth-teller for the
+    full depth either way."""
     n = len(pending)
     r = len(remote or ())
     if not n and not r:
@@ -41,9 +43,9 @@ def queue_height(pending, remote=None, collapsed=False) -> int:
         return 1
     rows = 1
     if r:
-        rows += min(r, QP_MAX_ITEMS) + (1 if r > QP_MAX_ITEMS else 0)
+        rows += min(r, max_items) + (1 if r > max_items else 0)
     if n:
-        rows += min(n, QP_MAX_ITEMS) + (1 if n > QP_MAX_ITEMS else 0)
+        rows += min(n, max_items) + (1 if n > max_items else 0)
     return rows
 
 
@@ -66,13 +68,22 @@ def pull_item(pending, buf, index: int):
     return item
 
 
-def _item_handler(pull, index: int):
+def _item_handler(pull, index: int, forward=None):
     """One row's mouse handler: MOUSE_UP (a click, not a drag/press) pulls
     THAT queued item into the input via `pull(index)`; every other event
     falls through (NotImplemented) so wheel scroll etc. keep today's
-    behavior. Mirrors OutputPane._SelectControl's event discipline."""
+    behavior. Mirrors OutputPane._SelectControl's event discipline.
+
+    `forward` (W2 Task 8, `OutputPane.forward_mouse`) gets FIRST refusal
+    when given: prompt_toolkit routes mouse events by pointer position, so a
+    drag armed on the pane above can end up releasing on this row — a real
+    click and a forwarded drag-release are indistinguishable to THIS row
+    except by asking the pane. Consumed (a drag was armed) ⇒ stop here,
+    pull is NOT called — the row must not also register as a click."""
     def _h(mouse_event):
         from prompt_toolkit.mouse_events import MouseEventType
+        if forward is not None and forward(mouse_event):
+            return None
         if mouse_event.event_type == MouseEventType.MOUSE_UP:
             pull(index)
             return None
@@ -80,12 +91,15 @@ def _item_handler(pull, index: int):
     return _h
 
 
-def _toggle_handler(toggle):
+def _toggle_handler(toggle, forward=None):
     """Header mouse handler (Task 11 click-to-collapse): MOUSE_UP toggles
     collapse; everything else falls through (NotImplemented) so wheel scroll
-    keeps working — the exact event discipline of _item_handler."""
+    keeps working — the exact event discipline of _item_handler. `forward`
+    (W2 Task 8) is the same first-refusal seam as _item_handler's."""
     def _h(mouse_event):
         from prompt_toolkit.mouse_events import MouseEventType
+        if forward is not None and forward(mouse_event):
+            return None
         if mouse_event.event_type == MouseEventType.MOUSE_UP:
             toggle()
             return None
@@ -94,7 +108,8 @@ def _toggle_handler(toggle):
 
 
 def queue_fragments(pending, pull=None, width: int = 0, remote=None,
-                     collapsed=False, toggle=None):
+                     collapsed=False, toggle=None, max_items=QP_MAX_ITEMS,
+                     forward=None):
     """PURE builder: the panel as prompt_toolkit formatted text, re-invoked
     every redraw (same live mechanics as the toolbar) so every queue
     add/edit/drain shows at once. Layout, top→bottom = drain order (FIFO —
@@ -103,7 +118,9 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
 
         ⋯ queued (N) · ↑ edit last · click to edit
         [telegram] remote item   ← remote rows ABOVE local (qp.remote)
-        … +K more            ← only when N > QP_MAX_ITEMS (the OLDEST hide)
+        … +K more            ← only when N > max_items (the OLDEST hide;
+                                defaults to QP_MAX_ITEMS, overridden by the
+                                dock with a live sizing.panel_cap(rows))
         older item           ← muted (qp.item)
         newest item          ← accent (qp.last)
 
@@ -122,7 +139,13 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
     `collapsed` (Task 11 click-to-collapse) folds the whole panel down to
     ONE header row ending `▸` (screen space back on demand); `▾` when
     expanded. Both only render when `toggle` is given — the header then
-    carries a 3-tuple MOUSE_UP handler (see _toggle_handler) that flips it."""
+    carries a 3-tuple MOUSE_UP handler (see _toggle_handler) that flips it.
+
+    `forward` (W2 Task 8) is forwarded into every _item_handler/_toggle_handler
+    built here — see their docstrings; it is the pane's
+    `OutputPane.forward_mouse`, given first refusal on every row/header click
+    so a drag armed on the pane above can still be extended/completed once
+    it releases on this panel."""
     items = list(pending)
     rem = [r for r in (remote or ()) if isinstance(r, dict)]
     n = len(items)
@@ -131,13 +154,13 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
     marker = "" if toggle is None else (" ▸" if collapsed else " ▾")
     header = ("class:qp.header", f" ⋯ queued ({n + len(rem)}){marker}")
     if toggle is not None:
-        header = header + (_toggle_handler(toggle),)
+        header = header + (_toggle_handler(toggle, forward),)
     frags = [header]
     if collapsed:
         return frags
     if n:
         frags.append(("class:qp.item", " · ↑ edit last · click to edit"))
-    rstart = max(0, len(rem) - QP_MAX_ITEMS)
+    rstart = max(0, len(rem) - max_items)
     if rstart:
         frags.append(("class:qp.remote", f"\n   … +{rstart} more"))
     for r in rem[rstart:]:
@@ -149,7 +172,7 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
         row = "\n   " + one_line(f"{mark}[{origin}] {r.get('text') or ''}",
                                  width - 4 if width > 0 else 0)
         frags.append(("class:qp.remote", row))
-    start = max(0, n - QP_MAX_ITEMS)
+    start = max(0, n - max_items)
     if start:
         frags.append(("class:qp.item", f"\n   … +{start} more"))
     for i in range(start, n):
@@ -158,5 +181,5 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
         if pull is None:
             frags.append((style, row))
         else:
-            frags.append((style, row, _item_handler(pull, i)))
+            frags.append((style, row, _item_handler(pull, i, forward)))
     return frags

webbee-0.3.18/src/webbee/reflow.py

@@ -0,0 +1,53 @@
+"""Pure prefix-sum math behind OutputPane.reflow (W2 front-2: true width
+reflow). A terminal-width change re-wraps every retained record, which
+shuffles absolute line indices around — the only stable anchor across a
+re-wrap is which RECORD produced the top-visible line, not the line index
+itself. Kept as free functions (no OutputPane/Rich/prompt_toolkit import) so
+the anchoring math is unit-testable without constructing a real pane."""
+from __future__ import annotations
+
+
+def record_at_line(record_lines: list[int], line: int) -> int:
+    """Record index whose lines cover absolute content line `line`, via a
+    prefix sum over per-record line counts. Falls back to the last record
+    (or 0 for an empty ring) once `line` runs past every recorded span —
+    covers both a stale/out-of-range offset and the trailing placeholder
+    line that follows the final recorded newline."""
+    acc = 0
+    for idx, n in enumerate(record_lines):
+        acc += n
+        if line < acc:
+            return idx
+    return max(0, len(record_lines) - 1)
+
+
+def anchor_offset(record_lines: list[int], top_record: int, max_off: int, follow: bool,
+                   base: int = 0) -> int:
+    """New `_offset` after a reflow. Tail-follow snaps straight to `max_off`
+    (line indices are meaningless post-rewrap, so there's nothing to anchor
+    to). Otherwise the anchor is the NEW start line of `top_record` — `base`
+    (the buffer lines preceding the ring's first record, unaffected by a
+    reflow replay) plus the sum of every earlier RING record's span —
+    clamped so it never overruns the freshly re-wrapped content. Only valid
+    when the top-visible line was inside the ring (`_offset >= base`); the
+    pre-ring case is the caller's own no-op branch (those lines never
+    re-wrap, so their line index never changes)."""
+    if follow:
+        return max_off
+    return min(base + sum(record_lines[:top_record]), max_off)
+
+
+def records_to_drop(record_lines: list[int], dropped: int) -> tuple[int, int]:
+    """How many WHOLE records from the front fit entirely inside the first
+    `dropped` lines of a trim, and how many lines they cover — the boundary
+    record (partial overlap) keeps its full span rather than being split, so
+    the caller's actual cut moves UP to the nearest record boundary instead
+    of slicing into one. Returns (n_records, lines_covered)."""
+    acc = 0
+    n_drop = 0
+    for n in record_lines:
+        if acc + n > dropped:
+            break
+        acc += n
+        n_drop += 1
+    return n_drop, acc