* Interrupting sends no longer fail with "already has an active run"
Two sends that interrupt the same running agent raced: the first left the
foreground lane after cancelling and before reserving its new run, so the
second send's cancel ran in that gap, saw the agent still marked running,
and tracked a phantom run that made the first send's start throw.
Replacements now queue per agent in arrival order, and each cancels and
reserves its run inside one foreground mutation. A replacement that finds a
run still starting waits for it outside the lane, so Stop still reaches it.
Co-authored-by: Michael Wu <421504+michaelmwu@users.noreply.github.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* Interrupting sends still recover an agent whose turn never starts
A replacement now waits for a starting run only up to the rescue
timeout, then cancels it the way main did, so sending another message
still unsticks an agent whose provider never acknowledges a start.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* A queued replacement acts on the agent as it is when it gets the lane
Resolve the managed agent inside the foreground mutation instead of
before queueing, so a session reload while the send waits cannot leave
it writing state to, or checking steer ownership against, the old agent.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Co-authored-by: Michael Wu <421504+michaelmwu@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(app): keep keystrokes typed while a terminal restores its screen
When a terminal re-attaches, for example after the host reconnects, the
browser terminal replays the screen snapshot and ignores everything xterm
emits until the replay is parsed, so replies to queries in the restored
output don't reach the shell. That also threw away what the user typed
during the replay: the first characters typed right after a reconnect
were lost.
xterm emits both through the same callback. Replies only come out of
parsing a write, so data emitted while a keyboard, input or paste event
is dispatching on the terminal is the user's, and it now goes through.
* fix(app): keep pastes suppressed while a terminal restores its screen
Until the replayed snapshot restores bracketed paste mode, a multi-line
paste would reach the shell unbracketed and run line by line. Pastes
during a replay are dropped as before; only typed input goes through.
---------
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
* test(app): reproduce edited draft retries after a failed agent start
Resubmitting an agent draft after its start failed reuses the draft ID as
the creation key with different inputs, and the daemon rejects it with
agent_request_key_conflict (or workspace_request_key_conflict from New
workspace).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(app): start an edited agent draft after its first start failed
The draft sent its draft ID as the creation key on every submit. After a
failed start the daemon keeps that key's request, so resubmitting an edited
draft was rejected with agent_request_key_conflict. The key now names the
draft's exact request: a retry resumes it, an edit starts a new one.
A retry after New workspace's agent failed to start creates the agent in
the workspace that is already ready, instead of replaying workspace
provisioning with a different agent.
Co-authored-by: michaelmwu <421504+michaelmwu@users.noreply.github.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: michaelmwu <421504+michaelmwu@users.noreply.github.com>
* fix(app): keep the model picker's profile action tappable on Android
On Android tablets the model list scrolls inside an independent viewport whose native scroll gesture cancels a plain Pressable's touches. Rows use the gesture-aware pressable; the profile + and the Profiles pencil were left as plain Pressables. Route both through the same gesture path.
* test(app): cover the tablet model row's profile action on Android
Adds an agent-device journey that taps a model row's `+` in the New
workspace picker on an Android tablet and waits for the seeded profile
form. It fails on main, where the tap is swallowed, and passes with the
gesture-aware profile action.
Co-authored-by: moevis <moevery@gmail.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(app): make the tablet profile journey follow the documented setup
The journey now starts from a remembered model like its sibling, so it
runs after model-tablet.android.ad, and asserts that closing the profile
form leaves the remembered model selected, so a tap on `+` that also
selected the row fails it.
Co-authored-by: moevis <moevery@gmail.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(app): keep the no-profiles requirement for the tablet profile journey
With a saved profile the picker opens on its root view, which has no
Back, so the journey needs a host with no agent profiles.
Co-authored-by: moevis <moevery@gmail.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(app): hide the model row's profile action through its style
IconActionButton took a pointerEvents prop that only its web branch
applied, so a native caller hiding the action would get an invisible
button that still took taps. The hidden style now carries
pointerEvents: "none", which every pressable branch already applies,
and the prop is gone. The web journey checks the plus ignores taps
until its row is hovered.
Co-authored-by: moevis <moevery@gmail.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: moevis <moevery@gmail.com>
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
OMP import listings return a session file path, and the import helper stored
that path as both sessionId and nativeHandle. Records then carried a path in
sessionId while runtimeInfo carried the real id, which breaks identity-based
lookups and makes a later import of the same file look unrelated.
Prefer the resumed session's own describePersistence() identity and keep the
listed handle as nativeHandle, merging metadata so provider-specific fields
survive.
* Preserve partial code blocks in assistant selection copy
* test(app): cover partial code copies in the real assistant selection journey
Copying from a paragraph into part of a highlighted code block, or from
partway through a block out to the next paragraph, now has browser
journey coverage. On main both copies join the code lines into one line
and drop the fence.
Co-authored-by: Michael Wu <michaelmwu@gmail.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(app): keep indented code lines inside a copied list item
Copying a list item that holds a code block indented only the code lines
that start with a non-space character, so an indented line fell outside
the item and broke the fence. Indent every non-empty line of the item.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Michael Wu <michaelmwu@gmail.com>
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
A sheet hidden right after it was presented, such as the context usage
sheet when a plugin focuses the composer, could stay open. The dismiss
reached the sheet before it had measured its layout, and the library
drops a close it cannot position yet. The sheet then finished opening,
and the visibility tracker took that as presented while its owner
wanted it hidden.
The tracker now dismisses again when a sheet reports an open position
while its owner wants it hidden.
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
thread/items/list asks for 100 items a page. On image-heavy threads a page
can exceed the app-server's line cap, and the history stopped at the first
such page with a "too large to load" warning, dropping every later item
even when each one fits. The reader now halves the page and retries the
same cursor, and shows the warning only when a single item cannot fit.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* Stop hidden surfaces rebuilding the agent directory on every update
The favicon is mounted at the root of every web and Electron session, and it
derived the whole aggregated agent list to answer three questions: is any agent
running, does any want attention, does any need input. The aggregated list
allocates a projection per agent, deep-compares it, sorts the whole host and
rebuilds its identity cache, and useAggregatedAgents re-ran all of that on
every agent update on any host. The dock badge did the same for workspaces: it
materialised every workspace status and deep-compared the array for a number.
Both now read a scalar selector: selectFaviconStatus walks the agent maps and
returns one of three strings, and selectMacDockBadgeCount counts actionable
workspaces without building a list. A store write that leaves those values
alone no longer re-renders the root component.
useAggregatedAgents also treated `demand` as "hold the directory subscription"
but still subscribed to every host's agent map, so the closed command center
(useAggregatedAgents({ demand: open })) rebuilt the full list on every update
too. With demand false the hook now returns a stable empty result and stays off
the maps.
Measured on the many-agent-tabs harness (5 tabs, 20 s windows, agent_update
churn from a background host): the root favicon component rendered 1554 times
in 20 s before this change and 1 time after.
* Complete the host runtime mock in the favicon test
* Keep the profiling harness out of the fix
The harness scans every process environment to find the daemon. Whether
Paseo carries a renderer CPU harness, and how it samples processes, is a
separate decision from the rendering fix.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* Stop re-rendering the workspace screen on unrelated agent updates
useOpenAgentTabLabels subscribed the workspace screen to the host's whole
agent map. Every agent update on the host replaces that map, so each
update re-rendered the open workspace screen, its split panes and tab
menus. Subscribe only to the agents that have open tabs.
Co-authored-by: jl97mcad <56251999+jl97mcad@users.noreply.github.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* Test render isolation through pure selectors and the browser
Replace the JSDOM hook tests and module mocks with pure selector tests
and a browser test that updates an agent in another workspace and checks
the open workspace screen does not re-render. Memoize the favicon and
dock badge selectors on the session maps they read, so unrelated store
writes skip the scan, and pass directory demand as an object.
Co-authored-by: jl97mcad <56251999+jl97mcad@users.noreply.github.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: jl97mcad <56251999+jl97mcad@users.noreply.github.com>
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Fetch tool definitions for the bound session instead of the global manifest so plugin-contributed tools can be registered and invoked. Preserve global discovery for legacy callers and existing session filtering and execution authorization.
Cover session-only tool discovery, invocation, child inheritance, disabled and unrelated sessions, unbinding, and plugin reload.
* fix(app): render Mermaid diagrams in an unscaled offscreen staging container
* fix(app): keep gantt charts at a fixed width in the Mermaid staging container
Rendering into the oversized staging container gave gantt charts its
16384px width, because Mermaid sizes a gantt chart from the element it
renders in. The host then fit that width into the message column and the
chart drew a few pixels tall. Give gantt charts the 1200px width Mermaid
uses when there is no container width, so they report the same size
whatever frame the host gives the runtime.
Co-authored-by: FluidXin <266379324+FluidXin@users.noreply.github.com>
* fix(app): keep gantt charts as wide as the Mermaid frame
Pinning gantt charts to 1200px shrank them on iOS and Android, where the
measuring frame is as wide as the message column and gantt charts used
to fill it. Use the frame's own width instead, which is what Mermaid
read from the page before rendering moved into the staging container.
Co-authored-by: FluidXin <266379324+FluidXin@users.noreply.github.com>
---------
Co-authored-by: FluidXin <266379324+FluidXin@users.noreply.github.com>
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
* fix(server): answer workspace listings from the last paseo.json snapshot
Every workspace listing and update builds a descriptor per workspace, and each descriptor read that workspace's paseo.json through a stat inside the daemon-wide two-slot pool, with a 5 s timeout that counted the queue wait. With many workspaces and a few clients listing, the last workspaces timed out, dropped their scripts, and the timed-out reads still ran, so other requests waited minutes.
The projection path now answers from the last snapshot and re-checks it behind the caller once it is 2 s old (a clock stepped backwards counts as stale). Edits, worktree setup and metadata prompts keep the fresh read. The snapshot cap rises to 1024 roots so a listing over more roots than the cap does not evict the next root it needs.
* fix(server): check paseo.json on every listing, answer the last config only when the check is late
Answering listings from the snapshot showed the previous scripts on the
first listing after an external edit to paseo.json, such as a branch
switch or an agent editing the file, and nothing re-sent the update
once the background check saw the change. A file that stopped being
admissible also kept its old scripts indefinitely.
Listings and script status now check paseo.json as before. When the
check does not finish within the 5 s budget, they answer the last
config read for that root instead of no scripts. Edits and execution
keep failing on a late check.
Co-authored-by: Phieu Dinh <phieu@fiu.one>
* fix(server): keep the saved paseo.json as the last known config after an in-app save
Saving through the project config editor dropped the snapshot, so a
late check on the next listing showed no scripts for that workspace.
The save now records the config it wrote.
* fix(server): record the saved paseo.json without another filesystem read
Re-reading the file after the rename made a completed save wait on an
unbudgeted read. The save now records the config and file stats it
already has.
---------
Co-authored-by: Phieu Dinh <phieu@fiu.one>
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
* fix(app): send hardware arrow keys to the terminal on Android
TextInput.onKeyPress is built from the IME input connection, so physical arrows never reach it and fell through to the hidden input as caret movement. The hardware module now claims arrows while the terminal input (nativeID) has focus, and the input forwards them to the PTY with their modifiers.
* test(app): guard Android terminal hardware arrow delivery
Exercise physical arrow ownership through a real Android window and editable, including repeats, modifiers and ordinary text-field editing. The terminal case fails on main because Left moves the hidden caret; the following typed character is then discarded as a replacement.
Co-authored-by: moevis <moevery@gmail.com>
---------
Co-authored-by: moevis <moevery@gmail.com>
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
* docs(changelog): describe 0.16.0-beta.2
Folds the nine user-facing changes merged since beta.1 into the series entry and renames its heading. Highlights are unchanged.
* chore(release): cut 0.16.0-beta.2
Show Codex reconnect attempts and distinct warnings through existing timeline rows. Keep interrupted root retries running through child activity and settle them on recovery, turn end, session close, or process exit.
Closes#9236
Co-authored-by: whatamelon <39753493+whatamelon@users.noreply.github.com>
* feat(plugins): give plugins the agent's sidebar indicator and background flag
Plugin UI re-derived agent state from status and attention fields and could
not see background work, so it showed agents as done while a shell they left
running was still live. Agent snapshots now carry the sidebar's own bucket as
indicator/indicatorLabel, computed by the same function the sidebar uses so
the two cannot drift.
Lifecycle hooks and the agent.open.before request now carry `background`, so a
hook can skip a hidden helper agent without a lookup. A hook cannot change it;
an omitted value means unchanged, like metadata.
`finished` attention still means the turn finished; background work is the
indicator's concern.
* fix(plugins): keep session-open hooks that omit background typechecking
A hook that returns its own object instead of spreading the request has no
background field; the result type now treats it as optional, like metadata,
matching the runtime where an omitted value means unchanged.
* refactor(plugins): give agent snapshots the background work count instead of an indicator
* fix(plugins): keep legacy session-open hooks that omit background typechecking
When a plugin sent an invalid IPC message, the runtime terminated it by disconnecting the IPC
channel and then killing the process. Node never emits "close" for a child whose channel the
parent disconnected, and "close" is where the runtime handles an exited plugin, so the process
died but the plugin stayed in the catalog, its session stayed open, nothing reported the exit,
and calls to it failed with "does not contribute RPC" instead of "Plugin is not available".
terminatePluginChild() now only kills the process; the channel closes with it, and "close"
fires as for any other exit.
Co-authored-by: Brandon Elliott <923787+Brandon168@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(server): share one timestamp across workspace archive
* fix(server): restore workspace agents when unarchiving workspace
* fix(server): persist workspace recovery before restoring agents
Remove unused undo-list tracking and pass named restore requests. A failed workspace record write leaves its agents archived for retry.
* feat(app): rename sidebar workspaces in place on wide web layouts
At lg and up on web, Rename from a sidebar row's kebab or context menu turns
the title into an input instead of opening the modal. The input fills a box
exactly one title line tall and its focus outline paints outside that box, so
the row never moves. Enter or blur saves, Escape discards. Narrower and native
layouts keep the modal; the native-wide device flows drive it.
The field stays on screen, read-only, holding the submitted title until the
renamed workspace arrives. The daemon answers workspace.title.set before it
pushes the workspace update, and queues that update behind any in-flight ones
for the workspace, so closing on the answer would show the old title.
While editing, the row detaches its press, drag and context-menu handlers
rather than becoming disabled: a disabled row sets aria-disabled, which makes
the input inside it read as disabled. A ContextMenuTrigger with its menu off
now leaves the browser's own menu alone, so copy and paste work in the field.
The rename modal moves into the new workspace-rename module, and the unused
sidebar-workspace-row.tsx is removed.
* fix(app): keep a title renamed elsewhere when an untouched inline rename closes
The unchanged check compared the field's text against the workspace's live title, while the
field keeps the text it opened with. A rename from another client during an untouched edit
made closing the field send the old title back. The inline session now owns its starting
text for both the field and the unchanged check.
* fix(app): hold a saved inline title against the title it replaced
The field closed once the row's title moved off the one editing started from. When another
client renamed the workspace while the field was open, that title had already moved, so a
save closed the field on the daemon's answer and showed the other client's title until the
saved one arrived. The session now records the title at submit and waits for it to change.
* fix(app): close an inline rename that submits the row's current title
Saving the title another client had just set left the row's title where it was, so the
saved phase waited forever with the field read-only and the row's press and menu handlers
off. A submit matching the current title now closes without a request.
* fix(app): finish an inline rename when the row shows the accepted title
The saved phase treated any title change as confirmation of this save. A rename from
another client delivered before ours closed the field early and showed that title, and
saving a title the row already had never changed it, leaving the field read-only and the
row's handlers off. The daemon's response carries the accepted title; the field now closes
once the row shows it. That rule also covers a submit matching the current title, so the
special-case comparison for it is gone.
* fix(app): close an inline rename that a later rename supersedes
The daemon builds each workspace update from its latest record, so a rename committed after
ours was accepted can be published in its place and ours never appears. Waiting for the
accepted title then left the field read-only and the row's handlers off. The saved phase now
ends on the first title change the row renders after the answer, or on the accepted title
if it is already showing. The session tracks the row's title while saving so a rename
delivered before the answer does not count.
The highlight order of 0.16.0-beta.1 was wrong twice: first in the order the pull requests were collected, then with the maintainer's four named items on top in the order they were typed, which pushed Background tasks to fifth. The doc only said "biggest first", so there was no test to apply.
Changelog ordering now owns the ranking: reach and frequency, four groups, and what to do with a maintainer correction. The entry puts Background tasks back at the top; no wording changes.
The highlights shipped in the order they were collected, which put the plugin sidebar and composer sixth and seventh. Lines are moved whole; no wording changes. The release doc now says how to rank highlights.
MessagePreview learned it overflowed from onLayout, which arrives after
the mount has painted on web and Fabric. Every mount (opening the chat,
a prompt arriving, a row the list mounts again) painted the text hard-cut
with no fade or Show more, then grew the row by the control a frame later.
The expanded choice also lived in the row and reset with each remount.
Measure the body in a layout effect so the first commit carries the
control, and keep the expanded choice in a per-agent store the timeline
provides, as tool calls already do.
* fix(app): keep tool badge file actions separate from disclosure buttons
Render the disclosure and open-file actions as sibling buttons so hovering a file-bearing badge does not produce invalid nested HTML buttons. Preserve independent mouse and keyboard activation.
* fix(app): preserve the full tool badge disclosure hit area
The measuring surface is visible before layout replaces it with the positioned menu. Retry the original geometry assertions across that replacement instead of measuring it once.
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Brings the version shipped in v0.16.0-beta.1 into main: workspace versions and internal dependency ranges, exactly as tagged. The changelog entries on main already match the tag.
Foreground checks intentionally stay silent since #9242. Exercise the opening check instead, waiting for a durable cursor before reload so cached messages remain readable while the daemon answer is held.
Every release entry in CHANGELOG.md now leads with highlights: an unheaded
list above the first `###`. The app's What's new sheet, the website
changelog and the GitHub release body show the highlights and fold the
sections, the full record, behind one control. An entry without highlights
keeps its sections in view. docs/release.md carries the writing rules.
Installed apps fetch CHANGELOG.md from main and parse it with the parser
they shipped with, so the two heading rules are a compatibility surface:
`##` starts a release, `###` starts a section, and headings inside fenced
code are text. The app, website and release-script parsers now split an
entry the same way and each runs the shared cases in
scripts/test-support/changelog-structure.json. The release-script tests,
which no CI job ran before, are part of "Validate CI contracts".
Adds the 0.16.0-beta.1 entry (en and zh-CN) ahead of the release.
* feat(plugins): let a plugin put the cursor in any agent's composer
A pill could insert text but left the cursor elsewhere, so the user had
to click the composer before typing. Plugins can address any agent's
composer, and an author cannot know where the user is, so focus() owns
revealing the agent as well as focusing it.
A running agent's composer holds one pending request and navigates to
the agent, completing when an input that can take the keyboard attaches.
Drafts and the New workspace composer have nothing to navigate to and
must not pull the user back, so they reject when off screen.
* fix(app): stop treating a covered New workspace composer as on screen
The screen passed isPaneFocused={true}, so with Settings pushed over it
the input still counted as revealed. focus() on a held composer resolved
on native with no visible cursor, and rejected with the wrong error on web.
The screen now reports its real route focus.
* fix(app): reach a compact subagent's composer and keep a focus selection
A compact sheet has no composer, so focus() on a subagent without a tab
opened a read-only sheet and timed out. It now promotes the sheet to a
tab, the same path as Open as tab.
A pending focus ran inside the effect that attached the input, before a
later effect in that commit applied a prompt set alongside it, so its
selection was clamped against the old text. It now runs after the commit.
* fix(app): show a compact subagent's tab when focus promotes its sheet
navigateToAgent stops at the sheet, so nothing closed an Explorer panel
covering the promoted tab and focus() timed out. The promoted tab now
goes through the same reveal as any other navigated tab.
* fix(app): open focus targets as tabs and focus Explorer composers on compact
Promoting a sheet after navigating could not reach an open deferred
until the workspace loaded, so the request now asks for a tab up front
with asTab, which travels with the deferred open. That removes the
post-navigation promotion.
A compact composer counted as covered whenever the panel target was not
the agent panel, so one hosted in the Explorer could never take focus.
Coverage now follows the composer's own host.
* fix(app): judge compact composer coverage by where it is hosted
The Explorer dock always reported its pane as focused, so a workspace sheet
over an Explorer composer still counted as on screen and focus() put the
cursor behind the sheet. It now suspends pane focus like the main panes do.
A composer on a screen with no panes counted as a main pane, so an Explorer
selection left over from the workspace marked New workspace as covered and
focus() rejected on a visible input. Only the agent list can cover those
screens, because the Explorer lives in the workspace.
* fix(app): close the composer's own sheets and menus when a plugin focuses it
focus() judged a composer on screen by its pane and panel alone, so a sheet
or menu the composer opened over itself, like the compact controls sheet
that hosts plugin Actions or a Subagents track page, stayed up while the
cursor went behind it. Navigation cannot close those, so focus() now closes
them itself.
Sheets and menus register with the nearest OverlayDismissalScope while open.
The composer opens one, and the agent panel opens one around its whole chat
because the tracks render outside the composer; a nested scope joins the
enclosing one.
* fix(app): close a composer's open picker when a plugin focuses it
The thinking, provider-option and plugin selectors render Combobox, which
never joined the composer's overlay dismissal scope. focus() left the
picker open, resolved on the textarea's brief focus, and the picker's
focus enforcement then took the cursor back. Combobox now registers its
close while open, like sheets and menus.
* fix(app): close a composer's modals before focus places the cursor
An image preview opened from the composer stayed over it after focus()
succeeded: the shared Modal never joined the overlay dismissal scope.
Modal now registers its onRequestClose while visible. Closing it then
exposed a second race: a web modal hands focus back to the button that
opened it in the commit that removes it, after the cursor was placed.
Dismissal now resolves once every closed overlay has unregistered, and
the composer places the cursor after that, waiting at most 1s so a
plugin modal that refuses to close cannot hold the promise forever.
A focus request replaced by a newer one resolved immediately, even when
the composer never came on screen. It now settles with the newer one.
* fix(app): close every composer sheet on focus and keep the latest request
The context usage sheet opens through the bottom sheet visibility hook
directly, so it stayed over the composer after focus(). Registration
moves to that hook, which every controlled bottom sheet uses;
AdaptiveModalSheet registers only its desktop dialog.
Two focus() calls in one turn overwrote each other's wait for an
overlay to close, so the older one resumed a second later and put its
selection back. Callers now share each overlay's close, and the latest
request places the cursor while earlier ones settle with it.
On native, focus() reported success when the input refused focus, as a
non-editable input does during dictation. It now checks isFocused().
* fix(app): let a focus call made while the input attaches decide the selection
A queued focus was dispatched in a microtask after the input attached, so a
focus() made in between (from a mounting item, for example) was overwritten
by the older selection. Each call now carries its sequence number; a queued
request that is no longer the latest settles with the newer one instead of
placing the cursor.
* fix(app): close a workspace sheet that focus dismisses before it animates open
A bottom sheet modal that unmounts after presenting but before its first
animation is still INITIAL, and the library's portal unmount returned early
for that status. Its portal stayed on the host and kept sliding open with no
owner, so composer.focus() removed the sheet from the workspace but left it
covering the input. The patch unmounts the portal in that case.
The compact Explorer focus test also waits for the phone layout before
focusing, since focus otherwise resolved against the wide layout.
* fix(app): keep popovers above their trigger off it when content grows
Tooltips and menu popovers placed above their trigger were positioned by
their top edge. When their content grew after they painted, the new height
painted first at the old top, extending down over the trigger, and the
correction waited for onLayout and a second placement commit. Native
delivers those after the frame, so the grown card covered the trigger for
about 150 ms on Android; web commits both in one task and hid it.
A surface above its trigger is now held by its bottom edge: it sits on the
bottom of a holder that ends at that edge, so layout keeps the edge in
place however the content changes.
* fix(app): let presses outside a popover reach its backdrop on web
The holder that keeps a popover's edge in place set pointerEvents
"box-none" as an inline style. react-native-web only polyfills box-none
for compiled styles, so the browser received an invalid value, fell back
to auto, and the full-width holder swallowed clicks meant for the menu
backdrop. Clicking outside an open menu no longer closed it.
Set box-none through the pointerEvents prop, as the rest of the app does.
* fix(server): give streamed tool calls their final title from the first frame
Claude opens a tool_use block with `input: {}` and OpenCode reports a
pending part with `input: {}` before the arguments arrive. The shared
detail primitives rejected the empty input, so the first row carried an
`unknown` detail and rendered the raw tool name with a wrench icon
("Bash"), then switched to "Shell" and the terminal icon once the command
arrived. Grep/Glob, WebFetch and MultiEdit flipped the same way, and
WebFetch flipped again while only `url` had streamed.
A known tool with no arguments and no output now yields its canonical
detail with empty fields. The app already reads empty read/edit/write/
search/fetch fields as loading details; a shell with no command and no
output now reads as loading too, instead of opening an empty sheet.
* fix(server): keep a tool call's title while optional arguments arrive first
Claude writes a tool's arguments in whatever order the model chooses, so a Bash
call can stream `{description}` before `command`. That partial input failed the
Bash schema and the row fell back to "Bash" with the wrench icon until the
command arrived.
Parsing now retries a call without output as having no arguments when its
input does not yet satisfy its tool's schema. This happens once, over the whole
branch set, so tools with several input shapes (OpenCode apply_patch) still
reach the branch their complete input matches.
* fix(server): keep cold diffs out from behind background git fan-out
Add a background lane to the git process scheduler and run reconciliation
checkout reads, observation-driven workspace refreshes and background fetches
in it. Bound reconciliation checkout reads to four at a time. Stop the Linux
file observer's startup scan from reporting existing files as creates, which
made every cold diff compute and discard its first revision.
* fix(server): pick the git job when its start token fires
Background jobs that already reserved a start-rate token no longer start
ahead of normal work submitted after them.
* fix(server): re-read the working tree once its watcher covers it
The Linux observer no longer reports pre-existing files at startup, so an
edit made between a workspace's first snapshot and its watcher subscribing
reached no consumer. WorkspaceGit now runs one background working-tree read
once observation setup completes with a live watcher.
Demand refreshes keep the caller's Git lane instead of forcing normal, so
user actions running at high priority are not demoted.
Scope the populated-tree observer test to Linux (FSEvents replays recent
writes) and update the observer benchmark test, which expected the removed
startup batch.
* fix(server): re-read checkout metadata once observation covers it
A branch switch made before the Git metadata watcher subscribed left the
cached branch stale. The post-coverage read now refreshes structure as well
as the working tree, matching the refresh the Linux startup events used to
trigger.
Hiding the Changes panel releases its diff subscription. Reopening it starts a
new stream, and since #8907 a new stream first publishes a loading snapshot
(entries, no bodies) before its first revision commits. That snapshot replaced
the settled diff in the query cache, so the panel showed the full loading
spinner for about a second and then repainted the same diff.
A loading snapshot now only counts on the first load. Once a diff has settled,
shareCheckoutDiff keeps it until the new stream's ready revision lands, which
replaces it in one step when the content changed.
The agent's usage query used gcTime 0, so every close dropped its reports
and every open started from the loading state. The drop existed because an
agent resumed under another login keeps its ID. The daemon now projects an
opaque usageScopeKey that follows the harness session and model, the query
key includes it, and reports are retained for as long as the scope holds.
Hover cards placed above their trigger now hold their bottom edge. Anchored
by top, a card that grew painted past the trigger until onLayout corrected
it on a later frame.
Every freshness check escalated to "pending" once FRESHNESS_CHECK_QUIET_MS
(500 ms) passed without an answer, so any round trip slower than that
flashed Updating messages for an idle chat the daemon then called current.
On Android that fired on a sub-second app switch over a slower link, and
after a reconnect it replaced Reconnecting to host with a second toast.
Each check now records why it was asked. Only opening a chat escalates
after the quiet period. A reconnect stays "reattaching" (Reconnecting to
host) until the answer. A foreground resume on a socket that stayed
connected stays silent: the chat never left its subscription, and a socket
that died without closing fails the foreground liveness probe and becomes
a reconnect. A "behind" answer still shows Updating messages until the
fetch lands.
* fix(app): keep plugin composer items in the toolbar when they fit
The density budget guessed a plugin item's width from a fixed label and
counted every registered item, so an icon toggle or an item rendering
nothing pushed the toolbar into its overflow state with room to spare.
An item is an arbitrary component, so its width is only known by
rendering it. Measure the toolbar form in an always-mounted slot; the
width never depends on the density it decides, so moving items to the
overflow cannot flip the answer.
Sheet rows truncated short values such as "Full access" because the
value's 45% cap resolved against a content-width row. Fill the row so
the cap resolves against the sheet's width.
* fix(app): close a plugin picker when its trigger moves to the overflow
The measuring slot keeps toolbar plugin items mounted, so a picker that
was open when the toolbar condensed lost its trigger but kept its popup,
which portals to the overlay root. Mark the slot's items inactive while
they are out of the row, the contract retained panels already use to
close their popups.
* test(app): allow the Updating messages toast when the daemon answers slowly
A freshness check unanswered after 500ms reports Updating messages by
design, but the resume spec asserted no toast regardless of how long
the daemon took. On a loaded runner a cold reload's answer took 512ms,
so the toast was correct and the spec failed. Assert no toast only when
the answer came back promptly, using answer times the gate records.
* test(app): check the Updating messages toast the same way on every run
The previous repair skipped the no-toast assertion whenever the daemon
took 300ms or more to answer, so a slow run proved nothing. The toast is
correct once a check has gone unanswered for the quiet window, so the
spec now always asserts that the toast did not appear sooner than that
after the question was sent, timed in the page. The delayed-answer path
gets its own test that holds the daemon's answer.
Touch-sized, each toolbar control now lays out at its whole highlight with no gap, so neighbouring highlights touch instead of hanging into gaps through negative margins. The row's overhang puts the attach glyph and a leading label on the composer's rail, and the trailing disc keeps a small clearance from its neighbour.