The just-sent (or queued) message slides up 20px, fades and grows from
0.96 over 280ms on an emphasized decelerate curve. Only a send marks it:
history, scroll restore, other devices, replies and the server copy
replacing the local one appear in place. Row keys follow the operation
id so the server copy keeps the row. Reduced motion shows it at once.
The capture fixture now accepts chat_prompt.
The composer's /new used to create a separate chat. It now sends
chat_new_session. The server starts a fresh native session on the chat's
own harness (OpenCode, Codex or Claude Code) and re-keys the
operator_sessions row in one transaction. The chat keeps its title,
directory, backend, colour, star, model and mode. The old row is kept
unlisted with replaced_by, and its native session stays resumable.
The reply and the chat_session_changed push carry previous_id, so every
client swaps the row in place and an open conversation follows it to the
fresh, empty transcript with a notice.
Two or more consecutive Claude Code task notices fold into one
task_notices row: a chip 'N background tasks' (tinted when one failed)
that opens a sheet with one compact row per task (outcome icon, summary,
outcome word), like the tools and permissions chips. A lone notice stays
one line. The server also treats Claude Code's [SYSTEM NOTIFICATION]
banner as harness text, so a bannered notification without an origin is
still a notice, never the operator's turn. The chat fixture gains
?tasks=N.
After a send the view jumps to the end of the conversation and resumes
following, even when the operator had scrolled up or the message is taller
than the screen, so the message's end and the reply stay in view.
The chat information sheet gains a Session section: the harness's native
session id (copy), harness, directory, a verified resume command (copy)
and Export conversation (Markdown), Export JSON and, for Claude Code,
Export native session (the JSONL transcript).
Server: chat_sessions rows carry resume_command and native_export; new
chat_export command builds Markdown/JSON from the same paged history
chat_messages serves (bounded at 8 MiB), refuses non-operator sessions.
App: exports go through the artifact file bridge (web download, share
sheet on phones).
At the field's line limit, a newline at the end left the caret on an empty
line the field only scrolled to after the next character. The field now
scrolls to the end right after such an edit.
The message field grows up to 12 lines (was 6) before it scrolls, capped at
about 40% of the visible height with the keyboard excluded, so the
conversation stays in view on a phone.
Root causes found in release web captures (1280x800 and 560x900):
- Follow mode undid small wheel/trackpad ticks at the end: each tick is its
own scroll, re-judged as following within 32 px and jumped back. A user
scroll toward older rows now releases the end however small; the jump
control appears once streamed content moves the end beyond the threshold.
- The end-of-scroll jump ran inside the position's activity switch, so a
touch or scrollbar drag released near the end recursed without end (stack
overflow during the gesture). The jump now runs after the notification.
- Horizontally scrolling code blocks and tables claimed diagonal trackpad
gestures whole. HorizontalScrollView gives mostly vertical gestures to the
enclosing list; sideways and Shift + wheel still scroll the block.
- The wheel over the floating chat bar, composer and jump control moved
nothing. VerticalWheelForwarder scrolls the transcript from them unless
something under the pointer claims the event.
Adds widget tests per content kind and scroll mode, follow/touch/Load older
tests, a capture-kit check (tool/capture/examples/chat-wheel-scroll.json)
with eval/expect steps, wheel dx/repeat, --params and eval: targets, a
transcript scroll probe and fixture options, and fixes the kit ignoring a
script's size. Notes in notes/chat-wheel-scroll.md.
Usage frames carry optional usage.account {harness, source, plan, as_of,
windows[{id,label,used_percent,resets_at}], unsupported}. Claude Code quota
comes from its rate_limit_event stream lines and the initialize account
(plan), shared across chats on the same account. Codex reads
account/rateLimits/read once per connection (re-read when a chat opens after
5 min) and merges account/rateLimits/updated. OpenCode exposes no quota API
and says so. The app's chat info sheet shows an Account usage section with a
progress bar and reset countdown per window, Material and Cupertino.
Claude Code records subagent/peer reports, task notifications, reminders and
skill bodies as user-role entries. Classify them server-side (history and live
stream) by origin/isMeta/queued_command mode: reports become kind agent_report,
task notifications kind notice, harness meta is hidden, and the mid-turn
wrapper is unwrapped to the operator's text. The app draws a collapsed Agent
report card and a one-line system notice on the agent's side.
Reuse unchanged transcript rows, the composer bar and the header across
streamed deltas, and share parsed markdown by text so rows scrolled back
into view are not parsed again. Adds a rebuild/parse harness and a
release-web frame-timing probe with a long-transcript fixture.
The thread reads the session's queued prompts from the chat_subscribe reply
and chat_queue frames: a reload draws them as Queued after the transcript,
a delivered one enters the transcript as Sent, a refused one becomes Not
sent, and Remove sends chat_unqueue. A prompt the server reports queued is
dropped from the device unsent store; the any-frame queued heuristic is
used only with a server that does not report its queue.
On web the engine closes the text connection on the editing element's blur,
which the browser fires just before the window blur, so the field is already
unfocused when lifecycle inactive arrives and FocusManager's own suspend and
resume restores only the route scope. Remember whether the composer held (or
had just lost) focus when the window left, and refocus it on resume, keeping
the caret and selection, unless another control took focus or a dialog,
sheet or route covers the chat. Desktop hosts only, so phones never get an
unasked on-screen keyboard.
The room that records a server-run turn is torn down when its last client
leaves, so a page reload re-subscribed to a new room that no longer knew the
turn was running and never replayed the step-started marker. Claude Code does
not re-announce a running turn to a new stream either, so the activity row and
Stop control vanished until the next streamed delta.
chat_subscribe now also replays the marker when the room's stream announced a
turn (CLI-originated or re-announced on attach) or when the broker reports its
own turn in flight through the optional chatTurnReporter (Claude Code reads its
in-process running flag; the chat manager routes it without I/O).
A sent message is stored on the device until the server accepts it, so a
reload mid-request no longer loses it: on reopening, a stored intent the
history records is cleared as sent, otherwise it shows as Not sent with
Retry (same operation id) and Edit. The operator's bubble shows Sending,
Sent (newest only), Queued or Not sent. A live refusal keeps the old
contract (exact draft and chips back in the composer, unchanged re-send
reuses the id) and marks the bubble Not sent with Retry. On web, leaving
or reloading the page while a prompt is in flight asks first.
The transcript listener read the lazily built _controller while _attach was
still building it (load() notifies synchronously), so it built another
controller, recursively, until the test process ran out of memory.
Extract the chat's segmented bar into lib/ui/adaptive (SegmentedBar,
GlassPill, SegmentedBarOverlay) and use it for the shell bar, DetailPane
and every page-level bar. Pieces are frosted glass over a fading scrim;
only pills take taps. Actions keep their natural width so the title gives
way before a model name. The chat transcript scrolls behind its header.
The dots were period glyphs sitting on the baseline, so they read low
beside the label. They are now round dots sized from the surrounding
text, vertically centred with it and scaling with it.
The open conversation draws its own bar of separate rounded pieces: the
platform Back in a circle, a title pill with the folder that opens the
chat information, and a pill with the model and mode controls. Detail
pages drop only their app bar for it, keeping the body mounted.
Operator-attached images render as rounded thumbnails above the user
bubble and open a zoomable Material/Cupertino viewer. Inline data: URIs
decode locally; file:// attachment-store URIs load through the new
chat_attachment_image websocket request, which serves only regular image
files directly inside the private attachment store (os.Root, <= 4 MiB,
sniffed raster types). Missing files show an 'Image no longer available'
placeholder; other files keep the file row.
On Android and iOS the keyboard's Return now inserts a newline and the
Send button sends; desktop keeps Enter to send. The Material activity
line drops TextButton's inset so it starts at the answer's edge now that
replies have no bubble.
Agent replies sit on the page without a bubble and get a copy control;
the operator's turn is a neutral rounded bubble; the composer is one
filled pill with +, a borderless field and a round Send, and its
placeholder names the chat's folder. Also fixes two picker tests left
stale by the native picker.
ChatScreen keeps a bounded in-memory cache of recently left transcripts
(16 chats / 4000 messages, LRU). A reopened chat is seeded from it with no
loading state, still re-subscribes and re-reads, and the newest page replaces
the cached copy while live frames received during the read are kept. /close
removes the entry; only transcripts backed by a successful read on the
current connection are written.
Adds tool/chat_reopen_probe.mjs and an optional history delay in the loopback
fixture. Measurement shows a second cost the cache does not remove: opening at
the end of the top-anchored transcript lays out every row (notes).