Round fitted window frames to whole logical pixels and accumulate drag deltas from the gesture start. This prevents floating-point size noise from rebuilding window content while preserving fractional pointer movement and resizing behavior.
Keep the Material-only template implementation and narrow its tests to the runtime path. Retain public Cupertino parameters for compatibility while removing unreachable hosts, widgets, and test variants.
Keep the public Cupertino-compatible parameters while retaining only the Material implementations and tests. The app is Material-only, so deleting unreachable Cupertino branches reduces dead code without changing the active path.
Keep the Material graph implementation while preserving public Cupertino parameters for callers. Remove unreachable Cupertino widgets, routes, theme branches, imports, and Cupertino-only tests because the app runs exclusively under MaterialApp.
Keep window content scope independent from frame changes, and retain the page theme and root page across layer rebuilds. Add repaint boundaries and regression coverage so dragging and resizing avoid unrelated content work while content changes still propagate.
Keep the app's Material-only chat workspace path while retaining public cupertino parameters for callers. Narrow the affected widget tests to the supported Material host.
Keep the public compatibility parameters while retaining only the Material UI path. Remove Cupertino-only tests so the reviewed settings and server code matches the app's Material-only runtime.
Keep the reviewed attention surfaces on their Material implementations while preserving public cupertino parameters for remaining callers. Remove the unreachable Cupertino sheet and narrow tests to the Material path.
Keep the Material-only file explorer path while preserving public APIs used by callers. Remove unreachable Cupertino widgets, hosts, routes, and tests so the app remains behaviorally unchanged on Material screens.
Keep onboarding on the app's Material-only path and remove unreachable Cupertino widgets and host-specific tests. Preserve the reviewed Material behavior while documenting the focused checks and verification limits.
Keep the Material update dialogs as the only reachable implementation while preserving public cupertino parameters for callers. Update focused tests and document the verified checks.
A browser keeps Ctrl+Shift+C for its developer tools, so on Linux and
Windows web nothing copied. With text selected Ctrl+C now copies it (and
clears the selection) instead of interrupting the process; Ctrl+Insert
copies too, and a finished run's read-only output answers the copy keys.
The terminal's options menu names the key.
Phase 4 of docs/plans/floating-windows.md. A bar button lists the app's
windows on every tab (show one, Show all, Minimise all, Close all). Alt+`
and Alt+Shift+` bring the next or previous window to the front. Dropping a
title at the left or right edge fills that half, at the top it maximises.
A new window of a kind opens at the size that kind was last given.
Phase 2b.2 of docs/plans/floating-windows.md, implemented by pipeline run
303: both use showAppChoiceMenu (a menu anchored to its button on a wide
app, a bottom sheet on a phone).
A dialog only in the tiled app on a wide layout: a phone keeps its
full-screen page (run 304 had turned it into a sheet and rewritten the
tests), and a floating window opens it as a page of that window so a diff
or command output it opens stays in the window.
The add-pane picker is opened from a pane, not a button; with no room
above or below the anchor the panel was laid out with no height (found by
run 303's UI review).
Phase 2b.4 of docs/plans/floating-windows.md: both use showAppDetails (a
dialog on a wide app, a bottom sheet on a phone). Implemented by pipeline
run 305; landed by hand after its UI review found the dialog clipped, which
the helper now scrolls.
Phase 3 of docs/plans/floating-windows.md. The terminal window kind reuses
TerminalHub; TerminalWindows keeps the window in step with TerminalLayout
(show opens or shows it, hide minimises it, Minimise and Close hide the
terminal). The bottom panel stays a shell panel. The first window takes the
frame and maximised state pipelines.terminal-layout.v1 saved.
The terminal's own float chrome and FloatingLayer are deleted.
Present chat turn and shell-history detail surfaces through the shared adaptive popup helpers so desktop uses dialogs while phone layouts retain bottom sheets. Update focused tests and document the verified behavior.
Use Material popup menus for file actions and anchor Runs sorting choices to the sort button while retaining the phone fallback. Update callers, tests, and implementation notes to match the desktop behavior.
Phase 2b.1 of docs/plans/floating-windows.md. showAppChoiceMenu is a menu
panel anchored to its button on a wide app and a bottom sheet on a phone;
showAppDetails is a dialog or a bottom sheet. Both are on the root
navigator, and the app's width decides, so content in a narrow floating
window still gets desktop popups. The probe window exercises both.
AppMenuAnchor is the app's one MenuAnchor: root overlay, takes the keyboard
while open (Escape and arrows work wherever focus was) and gives it back.
A window no longer takes the keyboard back from a popup its own press
opened. In a window, Files opens as a page of that window and Chat details
is in the More menu.
Phase 2.3 and 2.4 of docs/plans/floating-windows.md. A floating chat is a
window of the chat kind over the app's WindowManager, built from the
app-lifetime ChatRuntime, so it shows over every destination and at start
without the Chat destination being built. Float and Dock move the same
keyed view between the tiling and the window host. The pipelines app keeps
one runtime and one ChatWindows; saved chatFloat records (v1 and v2) are
brought over once.
ChatFloatHost, ChatFloatWindow, the float frames and binding, the
controller's float list and FloatingFocusRoot are gone; the workspace only
asks whether a chat is out in a window. Every MenuAnchor targets the root
overlay (guarded by a test), and menus and tooltips name the Alt chords.
Phase 2.2 of docs/plans/floating-windows.md: buildChatPaneContent wraps a
conversation in the scopes it needs and keys it by the runtime, so the
tiling and (next) a floating window build the same subtree. The tiling uses
it; behaviour is unchanged.
Phase 2.1 of docs/plans/floating-windows.md. The session list controller,
opened rows, accepted models, transcript positions and caches, composer
focus requests and list folds move from ChatScreen's state to ChatRuntime.
ChatScreen builds its own unless one is passed; behaviour is unchanged.
Phase 1.3 and 1.4 of docs/plans/floating-windows.md. Windows are plain
children of the terminal stage's stack in the shell page, outside every
destination, so popups opened from one are above all of them. Each window
has its own page navigator: pushed pages open inside the window, and popup
routes go to the root navigator. One WindowFrame chrome (move, resize,
minimise, maximise, close), a focus scope per window, a ScaffoldMessenger
per window.
No feature uses it yet. The capture fixture opens probe windows with
?windows=N, and window_layering_test.dart covers every popup type from a
window over Chat and over another destination.