From 61d60a97ea4f2032b2b45e007488183e27989939 Mon Sep 17 00:00:00 2001 From: Tristan Simas Date: Wed, 18 Nov 2026 10:14:34 -0500 Subject: [PATCH 1/3] qt history: a glide into a tall arrival pins its header without the reader scrolling The scroll handler returned for the window's own scrolls (`layout_scroll`: the arrival glide, landing on the end, keeping the reader) before it repinned, so a message taller than the window that the reader followed into kept the previous message's header pinned until they scrolled (Tristan, Android). Every offset now repins, as `repin_header` says it is called and as Textual does. `tall_arrival` drives it on the live bus: #scratch following its end, scratch-live-pipeline posts 120 lines. Before: pinned "user -> #scratch 10:08:20" (the previous message). After: pinned "#scratch <- scratch-live-pipeline 10:14:10", the arrival's own header. `arrival` takes BURST (posts at once, default 3) and reports each post's wait to its row. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01RnH6dT7wdh7i4tjJZQdFu3 --- src/toad/qt/history.py | 5 ++++- tools/qt_drive.py | 43 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 46 insertions(+), 2 deletions(-) diff --git a/src/toad/qt/history.py b/src/toad/qt/history.py index d28ed9c8d..f38195444 100644 --- a/src/toad/qt/history.py +++ b/src/toad/qt/history.py @@ -1319,6 +1319,10 @@ def scrolled(self, value: int) -> None: fires `respond_to_scroll` once on the transition out of Dragging. The at_end/follows_tail transitions here stay — they're cheap state flips and consumers (jump bar + anchor) need to see them during drag.""" + # Every offset pins, the window's own as well as the reader's: a glide down into a tall + # arrival moves the top row into it, and returning before this left the arrival's header + # unpinned until the reader scrolled (Tristan, Android, 2026-11-18). + self.repin_header() if self._restoring: return if self.at_end and not self.follows_tail: @@ -1327,7 +1331,6 @@ def scrolled(self, value: int) -> None: self.release_anchor() elif not self.follows_tail: self.reader_position = RowPosition(value) - self.repin_header() if self._scroller_dragging: self._drag_skipped_ticks += 1 return diff --git a/tools/qt_drive.py b/tools/qt_drive.py index 529ef3250..81e4cc9be 100644 --- a/tools/qt_drive.py +++ b/tools/qt_drive.py @@ -828,6 +828,35 @@ async def run(self) -> None: assert not facts["shown"], "the message's own header is on the top row, yet a copy is pinned" +class TallArrivalScenario(StickyScenario): + summary = ("open TARGET (#scratch) following its end; SENDER (scratch-live-pipeline) posts one " + "message taller than the window; once the window glides down into it, its header " + "must be pinned over the top row without the reader scrolling") + + async def run(self) -> None: + self.app.resize(int(os.environ.get("WIDTH", 412)), 915) + target = os.environ.get("TARGET", "#scratch") + sender = os.environ.get("SENDER", "scratch-live-pipeline") + await self.open_named(target) + window = self.page.messages + await until(lambda: window.follows_tail, "following the end") + stamp = time.strftime("%H:%M:%S") + body = "\n".join(f"tall arrival {stamp} line {line}" for line in range(120)) + process = await asyncio.create_subprocess_exec( + "agent-comms", "send", "--from", sender, "--to", target, "--type", "info", "--body", body, + stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.PIPE) + _, error = await process.communicate() + assert process.returncode == 0, error.decode(errors="replace")[-300:] + await until(lambda: any(f"tall arrival {stamp} line 119" in fragment.clipboard_text + for fragment in window.model_rows.fragments), "the tall message's row") + await until(lambda: window.glide is None and window.follows_tail, "the glide landed on the end") + await asyncio.sleep(0.5) + facts = self.pinned() + self.report("1-tall-arrived", **facts) + assert facts["shown"], "a tall arrival fills the window, yet its header is not pinned" + assert sender in facts["text"], f"pinned {facts['text']!r} is not {sender}'s header" + + class EscapeScenario(Scenario): summary = ("in the scratch-live-pipeline thread, then #comms: scroll off the tail, press Escape in " "the composer, and report the view back on its latest row (BackToBottomAction, bound on " @@ -2066,6 +2095,8 @@ def sample() -> None: else (target, "user")) sender = os.environ.get("SENDER", sender) refused: list[str] = [] + posted: dict[int, float] = {} # when each post's send returned, s after start + burst = int(os.environ.get("BURST", "3")) # how many the sender posts at once async def post(index: int) -> None: # Under a CPU-throttled drive, the sender runs in a scope of its own (SENDER_SCOPE=1): @@ -2076,6 +2107,7 @@ async def post(index: int) -> None: "--body", f"arrival reply {index} {stamp}", stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.PIPE) _, error = await process.communicate() + posted[index] = time.monotonic() - started if process.returncode: # A refused post is a failed walk, never a quiet one. refused.append(error.decode(errors="replace").strip()[-200:]) # How long each arrival-handling call holds the loop: the pager's publish into the rows, @@ -2105,7 +2137,7 @@ def wrapper(*arguments, **options): await asyncio.sleep(0.5) top = window.indexAt(window.viewport().rect().topLeft()) reading = (self.label(top.data(HistoryRows.FRAGMENT)), window.visualRect(top).top()) - posts = [asyncio.ensure_future(post(index)) for index in range(3)] + posts = [asyncio.ensure_future(post(index)) for index in range(burst)] for index in range(0 if scrolled_up else 3): composer.editor.setPlainText(f"arrival send {index} {stamp}") composer.submit() @@ -2129,6 +2161,15 @@ def wrapper(*arguments, **options): by_text: dict[str, list[str]] = {} for label, marks in appeared.items(): by_text.setdefault(label.rsplit(" #", 1)[0], []).extend(f"{mark}{label[-5:]}" for mark in marks) + # Each posted message's wait: from its send returning to its row first showing. + shown_at = {index: min((float(mark[1:]) for label, marks in appeared.items() + if label.startswith(f"arrival reply {index} {stamp}") + for mark in marks if mark.startswith("+")), default=None) + for index in posted} + waits = sorted(round(shown_at[index] - posted[index], 2) for index in posted if shown_at[index] is not None) + print(f"burst of {burst}: {len(waits)} shown; wait from send to row (s): " + f"median {waits[len(waits) // 2] if waits else None}, max {waits[-1] if waits else None}; " + f"never shown {[index for index in posted if shown_at[index] is None]}", flush=True) # A message that leaves the rows after it showed, or shows under two keys, flickers. flicker = {text: sorted(marks, key=lambda mark: float(mark[1:].split("#")[0])) for text, marks in by_text.items() if stamp in text and len(marks) > 1} From eea82d48de1b18cf79157f06aadb490483ddb450 Mon Sep 17 00:00:00 2001 From: Tristan Simas Date: Wed, 18 Nov 2026 10:32:35 -0500 Subject: [PATCH 2/3] qt menu: a row is as tall as its lines need, so descriptions keep their descenders QtMenuRow set its button's minimum height to `lines x lineSpacing + margins`, and an explicit minimum overrides the layout's own: each line (an ElidedLine with 5 px contents margins) got 22 px, 12 of them for a 17 px font, which cut every descender on the phone ("proiect", "aqent's"). The row now takes its layout's own minimum (`totalMinimumSize`), never less than the touch target. `qt_drive menu_text` (touch, 412 wide): before 22 lines drawn at 12/17 px; after 22 lines at 17/17, none clipped. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01RnH6dT7wdh7i4tjJZQdFu3 --- src/toad/qt/menu.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/toad/qt/menu.py b/src/toad/qt/menu.py index 3bd1ff186..dea11c09c 100644 --- a/src/toad/qt/menu.py +++ b/src/toad/qt/menu.py @@ -72,16 +72,17 @@ def __init__(self, entry: MenuEntry, menu: QtMenu, chosen: Callable[[MenuEntry], self.label = ElidedLine(menu.row_text(entry)) self.label.setParent(self._button) text.addWidget(self.label) - lines = 1 if entry.description and not menu.input_modality.describes_inline(): description = ElidedLine(entry.description) description.setParent(self._button) description.setEnabled(False) # the theme's muted text, as a secondary line text.addWidget(description) - lines = 2 inner.addLayout(text, 1) - margins = inner.contentsMargins() - height = lines * self.fontMetrics().lineSpacing() + margins.top() + margins.bottom() + # The row is as tall as its lines need, as the layout measures them (each line's own + # minimum, margins included), never less than a touch target. An explicit minimum + # overrides the layout's own: one summed from line spacing gave each line 12 px of a + # 17 px font and cut every descender on the phone (`qt_drive menu_text`). + height = inner.totalMinimumSize().height() self._button.setMinimumHeight(max(44, menu.input_modality.row_height, height)) def _fire(self) -> None: From d873bee41f64ce4edd105dc44f4f67433233823b Mon Sep 17 00:00:00 2001 From: Tristan Simas Date: Wed, 18 Nov 2026 10:32:35 -0500 Subject: [PATCH 3/3] history pager: work that arrives while a read holds the source runs when it ends `WorkingTranscript.schedule_work` answered DEFERRED_WORK ("the caller decides whether to retry") and no caller retried: a revision's refresh that arrived while a page read ran was dropped. In a burst the last revisions always land mid-read, so its last messages stayed unread until something else changed. The working state now keeps such work (once per kind: a refresh reads everything new) and `finish_source_work` schedules it when the read ends; what arrives meanwhile is owed to that operation in turn. Shared pager: both frontends. `qt_drive arrival` with BURST=20 at phone speed (CPUQuota=45%, py-spy attached): before, 14 of 20 shown, the last 6 never; after, 20 of 20 in two runs, median wait 0.7-1.0 s. The drive now reports each post's wait, when Core's revisions reached the app, and `menu_text` checks menu lines under touch for clipping. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01RnH6dT7wdh7i4tjJZQdFu3 --- src/toad/client/history_pager.py | 4 +++ src/toad/client/history_state.py | 11 +++++++ tools/qt_drive.py | 51 ++++++++++++++++++++++++++++++-- 3 files changed, 63 insertions(+), 3 deletions(-) diff --git a/src/toad/client/history_pager.py b/src/toad/client/history_pager.py index 0bf8b1f6d..0455fd045 100644 --- a/src/toad/client/history_pager.py +++ b/src/toad/client/history_pager.py @@ -679,6 +679,10 @@ def finish_source_work(self, operation: WorkingTranscript) -> None: self.publish_core(TranscriptSourceWorkFinished()) if all(history.state.accepts_source_work for history in self.window.histories): self.window.reader_position.source_settled(self.window) + # Work handed over while this held the source; what arrives while it runs is owed + # to that operation in turn, so a burst's last revision is always read. + for work in tuple(operation.owed.values()): + self.schedule_source_work(work) def resume_source(self) -> None: self._source_state = self._source_state.resume() diff --git a/src/toad/client/history_state.py b/src/toad/client/history_state.py index f6a9865da..245d85f63 100644 --- a/src/toad/client/history_state.py +++ b/src/toad/client/history_state.py @@ -348,6 +348,17 @@ def __init__(self, source: TranscriptState, owner): self.reader_revision = owner.window.scroll_revision # The screen asked for rows beyond an edge while this work held the source. self.edges_wait = False + # Work handed over while this held the source, run once it ends (`owed`). + self.owed: dict[object, Callable[[], Awaitable[object]]] = {} + + def schedule_work(self, owner, work) -> SourceWork: + """Work arriving while this holds the source runs once it ends, once per kind: a + refresh reads everything new, so two owed refreshes are one. Returned as deferred, it + was dropped by callers that never retried, and a burst's last messages stayed unread + until something else changed (a phone-speed burst left 6 of 20 undrawn).""" + key = (work.func, work.args) if isinstance(work, partial) else work + self.owed[key] = work + return DEFERRED_WORK def rows_published(self, owner) -> None: self.source.rows_published(owner) diff --git a/tools/qt_drive.py b/tools/qt_drive.py index 81e4cc9be..01dc9814f 100644 --- a/tools/qt_drive.py +++ b/tools/qt_drive.py @@ -942,6 +942,35 @@ async def run(self) -> None: self.report("3-notice", notices=app.float_layer.shown_notices(), shown=app.float_layer.isVisible()) +class MenuTextScenario(Scenario): + summary = ("open the menu at WIDTH (412) and fail when any of its lines is drawn in less height " + "than its font's full height: the descenders of a description line were cut on the phone") + + async def run(self) -> None: + from pyqt_reactive.widgets.fitted_text import FittedText + self.app.resize(int(os.environ.get("WIDTH", 412)), 915) + await self.listed() + self.app.menu_panel.input_modality = TouchInput # the phone's: each description is a second line + self.app.menu.click() + await asyncio.sleep(0.5) + lines = [line for row in self.app.menu_panel.findChildren(QtMenuRow) + for line in row.findChildren(FittedText)] + clipped = [(line.text()[:30], line.contentsRect().height(), line.fontMetrics().height()) + for line in lines if line.contentsRect().height() < line.fontMetrics().height()] + if lines: + line = lines[0] + button = line.parentWidget() + print("line geometry:", dict(height=line.height(), contents=line.contentsRect().height(), + margins=(line.contentsMargins().top(), line.contentsMargins().bottom()), + minimum=line.minimumSizeHint().height(), button=button.height(), + button_minimum=button.minimumHeight(), panel_sheet=self.app.menu_panel.styleSheet()[:300], + app_sheet_label=[rule[:120] for rule in QApplication.instance().styleSheet().split("}") if "QLabel" in rule][:4]), + flush=True) + self.report("1-menu", lines=len(lines), clipped=clipped[:6]) + assert lines, "the menu shows no lines" + assert not clipped, f"{len(clipped)} menu lines drawn shorter than their font: {clipped[:3]}" + + class FeedbackScenario(Scenario): summary = ("the reader's feedback at a Pixel 8a's width: the wait a slow thread open shows in place, " "#comms' first page loading, an operation's wait floating over the page, a notice that " @@ -2042,9 +2071,22 @@ async def run(self) -> None: started = time.monotonic() original = HistoryRows.show + first_shown: dict[str, float] = {} # a row's full text, when it first showed + # When Core's revisions reach this app: the pace a burst can show at, at best. + from toad.client.connection import CoordinationAccess + revisions: list[float] = [] + observed = CoordinationAccess.revision_observed + + def revision_arrived(access, result, observing): + revisions.append(time.monotonic() - started) + return observed(access, result, observing) + CoordinationAccess.revision_observed = revision_arrived + def recorded(model, fragments): before = {self.label(fragment) for fragment in model.fragments} original(model, fragments) + for fragment in model.fragments: + first_shown.setdefault(fragment.clipboard_text, time.monotonic() - started) after = {self.label(fragment) for fragment in model.fragments} if model is not view.messages.model_rows: print(f"show on another model: {type(model).__name__} rows={len(model.fragments)}", flush=True) @@ -2162,10 +2204,13 @@ def wrapper(*arguments, **options): for label, marks in appeared.items(): by_text.setdefault(label.rsplit(" #", 1)[0], []).extend(f"{mark}{label[-5:]}" for mark in marks) # Each posted message's wait: from its send returning to its row first showing. - shown_at = {index: min((float(mark[1:]) for label, marks in appeared.items() - if label.startswith(f"arrival reply {index} {stamp}") - for mark in marks if mark.startswith("+")), default=None) + shown_at = {index: min((at for text, at in first_shown.items() + if f"arrival reply {index} {stamp}" in text), default=None) for index in posted} + print("posted at (s):", sorted(round(at, 2) for at in posted.values()), flush=True) + print("revisions arrived (s):", [round(at, 2) for at in revisions if at > min(posted.values(), default=0) - 1], flush=True) + CoordinationAccess.revision_observed = observed + print("shown at (s):", sorted(round(at, 2) for at in shown_at.values() if at is not None), flush=True) waits = sorted(round(shown_at[index] - posted[index], 2) for index in posted if shown_at[index] is not None) print(f"burst of {burst}: {len(waits)} shown; wait from send to row (s): " f"median {waits[len(waits) // 2] if waits else None}, max {waits[-1] if waits else None}; "