23 Commits

Include renames

Author	SHA1	Message	Date
Mohamed Boudra	686588c44b	feat(app): restore manual workspace sorting (#7771) ... Keep manual workspace order separate from automatic sorting so surviving pre-beta arrangements and subsequent drags remain available across mode changes. Created stays the default; data already discarded by the beta cannot be reconstructed.	2026-10-24 09:06:05 +07:00
Mohamed Boudra	6405edd8dc	feat(app): show consistent agent and workspace status in search (#7690) ... Share tab agent presentation and effective workspace status with Command Center. Preserve unchanged result identities so live directory updates only rerender the changed row, with bounded retention and browser regression coverage.	2026-10-23 14:35:27 +07:00
Mohamed Boudra	55a7590952	Sort sidebar workspaces and keep active overflow visible (#7635) ... Order ordinary sidebar workspaces by Created or Last prompt, preserve project and pin ordering, and keep later active or unacknowledged work visible beyond the first seven rows. Preserve reveal state through live updates and verify sorting, visibility, compatibility, and rendering behavior.	2026-10-22 19:59:28 +07:00
Mohamed Boudra	0d7a234e63	perf(app): preserve unchanged sidebar workspace projections (#7157) ... Reopening a retained sidebar rebuilt its entry collection and invalidated every project row despite unchanged workspace data. Preserve collection identity as well as row identity, while keeping membership and ordering changes observable.	2026-10-16 21:10:42 +07:00
4 people	0009a7e717	feat(workspaces): add background visibility (#5039) ... * feat(server): let clients create internal agents The daemon's own branch-name and commit-message generators run as internal agents: never persisted, listed, flagged, announced, or seen by plugin lifecycle hooks. Nothing outside the daemon could ask for one, because the wire config schema strips `internal` and the agent.create transform re-pins it. A plugin that runs a one-turn helper per event therefore left an archived session in History every time. Add an optional `internal` flag to `create_agent_request` (inherited by `agent.create.request`), copy it onto the config in the session's create path, and skip provider session persistence for it like the generators do. The client SDK forwards the flag on both creation paths and gates it once on `server_info.features.internalAgents`. Two daemon paths assumed every agent is public and had to follow: `resolveAgentIdentifier` now accepts a live agent by exact id, since the id set it matched against came from listings that exclude internal agents and left `wait_for_finish` answering "Agent not found"; and archiving an internal agent now closes it without writing the record that `registry.applySnapshot` used to leave behind, so `autoArchive` does not accumulate hidden files on disk. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * fix(server): keep internal agents whole through failure, archive, and wait Review follow-ups for internal agents: - A create that fails after the runtime is registered now closes the internal agent before rethrowing, so a hidden runtime cannot outlive the failed request. Public agents keep today's behaviour. - Archiving an internal agent cascades to attached children like any parent. cascadeArchiveChildren takes the parent record instead of reading it back from storage, where an internal agent never is. - The archived snapshot and last message of an internal agent stay readable by exact id for ten minutes, so create-then-waitForFinish returns the finished turn whether the wait lands before or after an auto-archive. Storage plays that role for public agents. - The internal-agent e2e scenarios live in the existing create_agent_request lifecycle suite rather than a new file. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * fix(server): cascade to live internal children and keep a failed internal create's worktree until it closes Internal children never reach storage, so the parent archive cascade scans live agents for them as well. A failed internal create now clears the created id only after the runtime is archived, so worktree cleanup cannot delete the directory under a runtime that would not close. Stored agent payloads carry lastError, so a retained failed helper reports its error through wait_for_finish instead of the generic message. * feat(cli,mcp): expose internal agents and document --no-wait paseo run gains --internal and create_agent gains internal, both forwarded to the create request. --no-wait becomes the documented spelling for returning immediately, matching paseo send; --background and --detach stay as hidden aliases under COMPAT tags. * test: follow the --no-wait rename and stub getRetiredInternalAgent * feat: list internal agents on request and add internal workspaces Internal agents stay hidden by default, but a caller can now ask for them: `fetch_agents_request` takes `filter.includeInternal`, snapshots carry `internal: true`, and `paseo ls --internal` shows them in an INTERNAL column. The app never passes the flag. Workspaces get the same flag. `workspace.create.request` with `internal: true` persists a hidden workspace: listings, update subscriptions, sync reads, empty-project counting, open-by-path, MCP `list_workspaces`, and plugin workspace hooks all skip it unless the caller opts in with `filter.includeInternal`. Every agent created inside an internal workspace is internal and unpersisted; AgentManager applies that from the workspace id before the plugin hook so creators cannot opt out. Archive and shutdown enumerate internal agents so nothing inside an internal workspace outlives it. Surfaces: `paseo workspace create --internal`, `paseo workspace ls --internal`, `paseo run --internal --new-workspace`, MCP `create_workspace({ internal })`, SDK `workspaces.create({ internal })` and `list({ filter: { includeInternal } })`. Clients gate on `features.internalWorkspaces`. Co-Authored-By: Claude <noreply@anthropic.com> * feat(workspaces): add background visibility with inherited creation defaults * fix(cli): resolve workspace callers on the selected daemon * test(workspaces): keep caller integration coverage in server suite * test(cli): exercise workspace callers through CLI integration harness * test(mcp): remove obsolete execution flags from browser fixtures --------- Co-authored-by: marvin-ambrozio <marvin@gustavo.eng.br> Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com> Co-authored-by: Mohamed Boudra <boudra.moha@gmail.com>	2026-10-09 09:31:50 +01:00
Mohamed BoudraandChristoph Leiter	c779ef06c5	feat(workspaces): add workspace labels (#3510) ... * feat(app): workspace labels baseline Existing labels implementation, committed as-is as the baseline for the UI redesign. Server, protocol, catalog store and sync are sound; the UI layer is reworked in the commits that follow. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): show workspace labels on the sidebar meta line Labels could be assigned and then appeared nowhere. They now draw as a chip on the workspace meta row, after the host, change request, checks and service, and they can be switched off from the Show submenu like any other item on that line. One palette, not two. `baseColors.workspaceLabel` was ten raw Tailwind 500s spanning a 1.9:1 to 4.5:1 contrast range — the exact set identity-colors.ts was written to replace. Label color is now the identity color of the same name, so a chip, a host badge and a CI check on one row sit in one contrast band. `workspace-labels/colors.ts` and its per-file `labelColorViolet` blocks are gone; `chip.tsx` and `swatch.tsx` are the only places a label color becomes ink. A row resolves its labels against its own host's catalog and nothing else. The cross-host projection answers too, but two hosts may give one name two colors and the merge settles that by target precedence and then alphabetical serverId — a row painted in a color its host never assigned is lying about the one thing the color is for. The meta row's doc comment argued against tinted chrome on that line. The chip is a deliberate exception — everything else there reports state and shares the state colors, a label is a name a person chose — so the comment now says that instead of contradicting the code. Alignment: - The chip is exactly as tall as the line: text at the row's 16pt lineHeight, no vertical padding, so a labelled row is the same height as an unlabelled one. - A label run that opens the line hangs left by the chip's own padding, landing the name on the rail the title above it uses. Mid-line the ground stays in the flow. - The swatch row reaches 44pt through hitSlop growing outward from a 20pt swatch, replacing ten 44pt colored blobs in the manager modal. - The picker's raw `<Plus>`, `<CheckSquare>` and `<Square>` go through withUnistyles with module-level mappings, at the menu's 14pt. Also fixes a bug this change exposed: `SidebarRowItemsSchema` is a strict object, so adding an item without a key there fails the whole settings write and silently loses every other Show toggle with it. A test now covers each item in SIDEBAR_ROW_ITEMS. Phase 1 of the workspace labels redesign. The filter menu, the picker's interaction model and the manager modal's layout are later phases. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): one Labels filter page with tri-state rows Filtering by label cost three levels: Display -> Labels -> Include -> a page of labels, or -> Exclude -> the same page again. It is now one page: every label across every host, one row each, leading with its colour dot. A row cycles off -> include -> exclude -> off. Include is MenuItem's own check; exclude is lucide's X, the check's own pair, at the same 16 in the same trailing slot, so the column does not shift as a row cycles. Exclude also dims the row, because a state you have to identify by its glyph is not one you read at a glance. Unlabelled is a row in the same list, with a hollow ring where the others carry their colour. Match any / all still appears only once two labels are included. Clear is absent, not disabled, when nothing is filtered. Manage labels sits at the bottom below a separator. The whole root row is gone when no host has a label — unless a filter is still active, since the merged catalog only counts online hosts and losing one would otherwise strand a filter that is still hiding workspaces. The page is titled Labels, so its rows stop repeating the word: "Match any", "Match all", "Clear filter". The two Match rows sit directly under the list they qualify and only appear once two labels are included, so the subject is already on screen. All nine locales move together, translated rather than transliterated — Arabic keeps its noun, where "أي" is a determiner that needs one to stay grammatical. SidebarLabelFilter collapses from four collections plus match to one Record<labelKey, "include" | "exclude"> plus match: a tri-state row is one value per label, so include and exclude can no longer disagree about the same name. Unlabelled keys off the empty string, which normalizeWorkspaceLabelName makes unreachable for a real label. toggleSidebarLabelSelection, countSidebarLabelSelections, sidebarLabelSelectionIncludes and deduplicateSidebarLabelNames go with the old shape; setLabelFilter becomes cycleLabelFilter and setLabelMatch, so the store owns its own transitions. No migration: labels are unreleased, so the old persisted shape never shipped, and migrateSidebarViewState already resets on a safeParse failure. The e2e manager step asserted "Red label color" on a swatch that Phase 1 renamed to "Red"; the selector follows the code, and the accessibility.color key behind the old string is deleted from all nine locales as unreferenced. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): assign labels on the menu's own rails The assign picker was a search box, a create row that unfolded an inline form under it, and hand-rolled label rows whose 44x44 checkbox pushed every dot and name off the rail the rows above them sat on. Nothing lined up with anything. Rows are `MenuItem` now: the colour dot in the 16pt leading slot, assignment as the trailing check the engine already draws for a chosen row. Using the engine's row is the alignment fix; there is no second row implementation to keep in step. Every press toggles and the menu stays open — assigning labels is multi-select, so the dual-target model (`source: "row" | "checkbox"`, `shouldCloseWorkspaceLabelPicker`) is gone along with the model's `close` dependency. You leave by dismissing the menu. Search is deleted. Nobody has enough labels to search, and the field was the thing pushing the list down the surface. `workspaceLabels.search` and `createNamed` go with it across all nine locales; `clearSearch` stays because the manager modal still owns a search field (Phase 4's copy, untouched here). `Create label` moves below a separator at the bottom and opens a page that replaces the list: a name field, the swatch row, one commit row. Picking a colour picks a colour — it no longer creates the label. A failed create keeps the draft and shows the error on the page; a successful one creates, assigns, and returns to the list with the row ticked. Both menus share one page definition. `SidebarWorkspaceMenu` and `SidebarWorkspaceContextMenu` each built the same `pages` memo; they now call `useWorkspaceLabelMenuPages`. Menu engine, all of it forced by putting a text input on a menu page: - `MenuTextField` — the form kit's `FormTextInput` carries a screen's geometry and lands its text 4pt inside the labels above it. This one is drawn as a row's own fill, so the box and the text sit on the row's two rails at once. - `MenuPageDefinition.hoverIntent` — a page you type into is not one the pointer opens or dismisses. Without it the create flyout opened on a pointer passing over the row, and threw the draft away when the mouse drifted off it while the hands were on the keyboard. - The sheet keeps `keyboardBehavior="interactive"`, not `extend`. With `enableDynamicSizing` the largest snap point is the content's own height, so a short page did not grow and the keyboard came up over the field. Caught on an iOS simulator, fixed, and re-shot. - `MenuItem` announces `selected` as `aria-checked`. The deleted checkbox said so; a check drawn and never announced would have been an accessibility regression. Tri-state rows (the filter page's exclude) still cannot announce themselves — menu-wide, still Phase 5's. `sidebar-workspace-row.tsx`'s `isTouchPlatform = platformIsNative || isCompact` is kept deliberately. On a compact web viewport there is no hover, so the row's trailing actions and kebab were unreachable and the labels menu with them; this is the documented `isHovered || isNative || isCompact` shape from CLAUDE.md. Evidence: /tmp/labels-p3-{wide,compact}-{light,dark}-{list,create}.png, the create page on iOS with the keyboard up (/tmp/labels-p3-native-compact-keyboard.png) and the clipped sheet it replaced (-before.png). `packages/app/e2e/browser/workspace-labels.spec.ts` rewritten for the new model, daemon-backed failure coverage kept for both the toggle and the create path, green with the menu unit suites. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): edit a label in one operation `workspace.label.rename.request` and `workspace.label.recolor.request` become one `workspace.label.update.request { name, newName?, color? }`. Both old RPCs are deleted outright — no COMPAT shim, because the labels feature is unreleased and neither name has ever been on a wire a user owns. The `workspaceLabels` capability flag stays; that one is how a new app detects an old daemon. Two calls could land half-applied, which left the catalog in a state nobody asked for and the UI with nothing true to say. One catalog commit now applies the name, the colour, or both. Renaming onto a name the host already has is rejected rather than merged, and the check runs inside the planner so a refused collision applies neither field. A label keeping its own key is not colliding with itself, so case-only edits pass. The manager modal follows: - The host selector is `HostFilter`, the pill History and Schedules use. `includeAllHost` is now a prop: a surface that edits one host's catalog cannot carry out "all". - Search moves to the sheet header, where it spans the header's own rails. As a body control it capped at the component's 420pt and left a hole on the right whenever a host filter wasn't beside it. `workspaceLabels.clearSearch` goes with the box that had a clear button. - A row no longer opens an editor. It carries a pencil in its trailing slot, hover-revealed on web and always visible on native and compact, on the canonical plain-View hover pattern with the press on an inner Pressable. - The edit view is a name field, the swatch row, and one Save that issues one update. Delete keeps its confirm and its affected-workspace count, and moves to `outline` — red belongs to the dialog, not to the surface that opens it. - Copy says edit, never rename or recolor, in all nine locales. `workspaceLabelErrorMessage` drops the `requestType=… code=…` the daemon client appends to every RPC failure. That is what a log wants, not what a user reads under a name field. `workspaceLabels.accessibility.color` stays deleted: the swatch's accessible name is already the colour's name, so nothing needed it back. Co-authored-by: Christoph Leiter <christoph@leiter.io> * chore(app): converge the labels phases The sweep at the end of the labels redesign: the three items earlier phases found and kept out of their own commits, one cross-phase pass, and the docs. `AdaptiveModalSheet`'s close button reaches its target with `hitSlop` instead of `padding`, which had inset its glyph 8pt from the rail the title, the search field and every trailing glyph below it sit on. This is shared chrome, so it moves the close glyph in every sheet in the app; measured on four of them across both paths — the labels manager desktop and compact, the shortcuts dialog, the rename sheet — and each one's trailing rail now agrees with its leading one. `MenuItem` takes `selected: boolean | "mixed"`. A tri-state row was silent to a screen reader: the check announced itself after the last phase, but exclude had no state at all, so an excluded label was indistinguishable from an untouched one. `"mixed"` is ARIA's own third state, the engine still draws the check only for `true`, and the row keeps supplying its own trailing mark — nothing in the menu engine learns what a label is. CLAUDE.md's platform-gating rules said "NEVER use `onPointerEnter`/ `onPointerLeave`", which is the opposite of what `docs/hover.md` and `constants/platform.ts` both mandate. It now names the real rule — hover on a plain `View`, press on a separate inner `Pressable`, and no `onHoverIn`/ `onHoverOut` on a `Pressable` that contains other pressables — and links the doc that owns it rather than restating it. The cross-phase pass turned up one real defect: the replica cache never learned about labels. `StoredWorkspaceSchema` had no `labels`, so a restored workspace came back unlabelled, and since the directory cursor is current on reconnect the daemon has nothing newer to send — the chips stayed gone for the whole session and the filter matched nothing. An optional field, a serializer line, and an assertion in the restore spec. Everything else measured onto its rails already. Left alone and logged: the per-row `Map` in `useWorkspaceLabelDefinitions`, and the display menu closing when the sidebar swaps to its empty state, which is confined to that swap and predates every phase here. `docs/architecture.md` and `docs/data-model.md` described rename and recolor; they now describe the one update commit, which fields it rewrites, and the per-host resolution a row's chips use. `docs/menus.md` documents the third item state where it already documents the other two. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): split the labels filter into include and exclude controls The Labels page rotated one row through off -> include -> exclude -> off, which billed the rare operation to the common one: clearing an include cost two presses and routed through exclude, so the sidebar visibly re-filtered into a state nobody asked for on the way out. The row now owns include and a control on its trailing rail owns exclude. Each is one press each way and neither is reached through the other. `cycleLabelFilter` becomes `toggleLabelInclude` and `toggleLabelExclude`; the store's map shape is unchanged, and setting either state clears the other for that label, so including an excluded row is still one press. A row is never both, so the trailing rail holds exactly one 16pt glyph in every state: the check, a permanent `X`, or the same `X` revealed on hover. `X` rather than a circle-slash for the reason Phase 2 settled it — `Ban` fills its box where the check does not, and the column twitches. The control fades rather than mounts and takes its 44pt target from `hitSlop`, so neither revealing it nor changing state moves anything: measured 453-469 on every row, wide and compact. The control carries a tooltip, gated to web where hover exists. It portals into the overlay root above the flyout with no backdrop of its own, and resting on it does not read as the pointer leaving the surface, so the menu stays up. Accessibility: the control is a `checkbox` named "Exclude {label}" with its own checked state, and it stays in the tree at opacity 0 on rows that have no visible mark, so it is reachable without hover. Keyboard focus reveals it, so tabbing to it never means pressing something invisible. The row keeps Phase 5's `selected="mixed"` for exclude. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): put include and exclude on their own rails on every label row Phase 6 gave the row include and its trailing rail a hover-revealed exclude. The rotation was gone but the awkwardness was not: `X` is the glyph this app dismisses things with, so on a filter row it reads as delete rather than exclude, and one rail with a changing occupant still means the row's trailing area keeps changing identity as you read down the column. Both controls are now on every row in fixed positions, and state is which one is lit. Nothing appears, disappears, swaps places or shifts: the check box is 429-445 and the ban box 453-469 on an included row, an excluded row and an untouched one alike, wide and compact. Because the ban is always there, include -> exclude is one press instead of two. The row still includes, and the check is that same action named. `Ban` rather than `X`. Phase 2 rejected it because its ink fills its 16pt box where a check's does not, so the column twitched when the two swapped on one rail. Nothing swaps here, so what is left is a weight difference: the ban is drawn at 14 inside a 16pt box, which is the visible optical correction available before it stops being a glyph. The box is what the rail is measured from and it stays 16. Lit is `foreground`, unlit `foregroundExtraMuted`. Not `foregroundMuted`, which is the obvious choice and is wrong here specifically: the Match rows further down the same page carry `MenuItem`'s own check in that colour to mean *selected*, so an unlit check in the same ink would say the opposite thing eight pixels above it. Excluded keeps Phase 2's dimmed row. Accessibility: the row keeps `selected` — `true` include, `"mixed"` exclude — and the two buttons carry no checked state of their own, so a label's state is announced once and its two controls read as the actions they are. Both buttons take a tooltip, gated to web with `enabledOnDesktop={isWeb}`, because on non-compact native `TooltipContent` falls back to a `Modal` with its own backdrop. Deleted with it: the `isHovered || isFocused || isNative || isCompact` reveal, the `opacity: 0` mounting, the hover-tracking `View` and the focus plumbing that existed to keep an invisible control reachable. Net -7 lines of code on this row, all of the growth in comments. The store is unchanged; both buttons and the row press map onto `toggleLabelInclude` / `toggleLabelExclude` as they are. The e2e's hover-reveal and `toHaveCount(0)` steps encoded the deleted behaviour and are replaced by a rail measurement taken in every state — relative to the row, since filtering moves the anchor the menu hangs off, and behind a settle poll, since the flyout scales in and a box read mid-animation is not a rail. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): reveal the label filter's controls, and stop the empty state closing the menu Phase 7 put the check and the ban on every label row at all times, which made a resting list of labels read as two columns of buttons with a filter somewhere behind them. A row now shows its own state and nothing else — a marked row its mark, an untouched row nothing — and hovering any row brings both controls up, the mark you have lit and the other one unlit beside it. So the column you read down is the filter, and the row you are pointing at is the one offering to change it. Nothing about the rails changed. The two boxes are laid out in every state and only their ink comes and goes: check 429-445, ban 453-469 on an included row, an excluded row, an untouched one, hovered or not, wide and compact. The reveal is opacity, never mounting, so it cannot move the row out from under the pointer that fired it. Hover is tracked on a plain `View` wrapping the `MenuItem` with the presses on the buttons inside it, since `MenuItem` is itself a `Pressable` (docs/hover.md); each control counts its own keyboard focus as revealed, so tabbing to one never means pressing something invisible; and `pointerEvents` follows visibility so a hidden control cannot be clicked. On native and compact there is no pointer, so both simply stand there. Everything Phase 7 settled is kept: `Ban` at 14 in a 16pt box, `foregroundExtraMuted` for unlit against `foregroundMuted` meaning *selected* eight pixels below, `spacing[2]` between the two with `hitSlop` tiling the gap, the row owning `aria-checked` while the buttons stay plain named actions, and both tooltips gated `enabledOnDesktop={isWeb}`. --- Excluding a label that empties the sidebar closed the display menu. Logged since Phase 2, narrowed in Phase 5 to the empty-state swap, owned by nobody. `SidebarLabelFilterEmptyState` was a component rendered *instead of* the list, with its own container and scroll view, and both branches were handed the same header element. Different subtrees, so React unmounted the header on the swap — and the header holds the display menu's trigger, so the popover went with its anchor. The empty state is now a body: both list modes render it where their groups would go, inside the scroll they already own and below the header they already render, and the swap can no longer reach anything above it. Cleared from that same still-open page, the way back out is the swap in reverse and it holds too. `ProjectModeList` was already the right shape — its "no projects yet" body sits below the header — but its header was conditional on `unpinnedProjects.length > 0 || hasActiveHostFilter`, which is the same bug written as a guard: keep the header when there is a filter to undo. The label filter joins that condition rather than getting a second mechanism. Both empty states move into `sidebar/empty-states.tsx` so the two list modes can render either without importing each other, which also leaves the card's geometry defined once instead of once per body. Still conditional, and left alone: a sidebar with no projects and no filter has no header at all, so clearing the last host filter on an empty sidebar closes the menu the same way. That one is the onboarding empty state, where a section heading over "Add a project" would be a heading over nothing, and no menu is reachable in the state it lands in. The e2e gets the step that would have caught this: exclude into the empty state, assert the page you pressed on is still up, clear from it, assert the same. Verified by reverting both list files to Phase 7 and watching it fail on "element(s) not found". Phase 7's rail assertions are kept as they are — offsets within the row, behind a settle poll — and joined by computed-opacity reads for the four states of the reveal. Evidence: /tmp/labels-qa-p8/, 28 shots plus INDEX.md — the resting list, a hovered row, an included row with the pointer away, and the empty state with the menu still open over it, at wide and compact in both schemes. Co-authored-by: Christoph Leiter <christoph@leiter.io> * feat(app): make the label filter include-only Phases 2, 6, 7 and 8 each tried to give exclusion a comfortable shape inside a 232pt menu row: tri-state rotation, a hover-revealed control, two permanent buttons, two hover-or-lit buttons. Every fix bought a new awkwardness, because two controls in one menu row is a lot of machinery for a filter. The label filter is now the host filter — one tap in, one tap out — and nobody has ever complained about that one. A row is a plain `MenuItem` with the colour dot leading and the engine's own check trailing. Nothing else. Which makes the alignment law trivial to satisfy, and that is the point. Deleted rather than disabled, since 6, 7 and 8 are in the branch history if exclusion ever comes back: both trailing controls, the hover-tracking `View`, the `opacity: 0` mounting, the focus/blur plumbing, the `pointerEvents` gating, both tooltips and their `enabledOnDesktop={isWeb}` gates, the lit/unlit token pair, `Ban`, and the two rails they held. `SidebarLabelFilter` collapses onto the shape of `hostFilters` sitting three fields above it in the same store: `labels: string[]` plus `match`, one `toggleLabelFilter`, one `clearLabelFilter`. The exclude arm of `filterWorkspacesByLabels` goes with it, and `filter.include` / `includeLabel` / `exclude` / `excludeLabel` leave all nine locales. Persisted version 4 with no migration — the record shape never shipped, and `createValidatedPersistStorage` drops state that fails the current schema before `migrate` ever runs. Two things this leaves unused, both deleted: - `MenuItem`'s `selected: boolean | "mixed"`, added in Phase 5 so a tri-state row could announce itself. The filter row was the only caller, so the union collapses back to `boolean` and the two `selected === true` guards that existed for `"mixed"` go back to plain truthiness. - The `docs/menus.md` paragraphs from Phases 7 and 8 on hover-revealing a pressable trailing control inside a menu row. No caller does that any more, so the doc was describing a pattern the codebase no longer has. Kept: `SIDEBAR_UNLABELLED_LABEL_KEY`, because `Unlabelled` is still a row and now includes like any other; `Match any` / `Match all`, because multi-select include still means two different things. Phase 8's empty-state fix is untouched and still holds — `hasActiveSidebarLabelFilter` is what the header's survival condition reads, and it answers the same question against the new shape. Evidence: /tmp/labels-qa-p9/, 12 shots plus INDEX.md — resting, two selected, and the empty state with the menu still open over it, at wide and compact in both schemes. Co-authored-by: Christoph Leiter <christoph@leiter.io> * fix(app): give label-grouped rows their project icons, and label groups a tag Grouping the sidebar by label rendered every workspace row with its placeholder initial. The same workspace under status or project grouping showed its real project icon. The components were reused; the data feeding them was not. One component served both grouping modes and threaded the icon map through correctly. Fourteen lines above it, a second `useProjectIcons` call was gated on `groupMode === "status"`, written when status was the only mode that put icons on rows. Phase 2 extended the render branch to `status || label` and left the gate alone. Nothing forces a render branch and the data it renders to agree, and these two were far enough apart to drift in silence. Reuse buys you one implementation of the drawing; it buys you nothing about who decides what to fetch. So the fix is the shape, not the line. There is now one `useProjectIcons` call for every mode, and its targets come from `buildSidebarProjection` — the same function that produced the rows, from the same `projects` list. A mode can only render a row for a project the projection already knows about, so the map cannot disagree with the screen. The gate is gone rather than extended: extending it would leave the identical trap for the next grouping mode. `useProjectIcons` dedupes by `serverId:projectId` and caches through `useQueries`, so the gate was a premature optimization that bought a bug. Pinned by `sidebar-projection.test.ts`: for each of the three modes, every project view key the projection will render — pinned rows, grouped rows, project headers and the rows under them — has an icon target. Red on the old gate: restoring `groupMode === "status" ? … : []` in its new home fails project and label grouping with `['project', 'other-project']` uncovered, and status passes, which is exactly the bug's signature. The sibling sweep over everything `SidebarStatusModeWrapper` is handed found one more of the same shape, correct today: the projection chose its shortcut sections with `status || label`, so a fourth mode would have silently walked the project rows. Both the groups and the sections now come from one exhaustive `switch` on the mode, which makes the next mode a compile error rather than an empty list. `workspaceEntriesByKey` is already written the safe way round (`!== "project"`), and the rest — host badges, pinning support, the empty-filter state — never read the mode at all. Two names moved with the shape: `SidebarStatusModeWrapper` is `SidebarGroupedModeList`, and its branch is `groupMode !== "project"`, so a new mode lands in the grouped list instead of the project list's `else`. Also: label group headers draw lucide `Tag` instead of `CircleDot`, in the label's colour, muted for `Unlabelled` — the glyph the Labels menu and the workspace menu already use for this feature. It keeps `StatusGroupIcon`'s 14 with no optical nudge, and that is measured rather than assumed: in the header's leading slot both ink a 14x14 box at the same offset, and the tag lays down 76 ink pixels to the circle's 84, so reaching the corners of its box costs it no weight beside the status glyphs. QA: /tmp/labels-qa-p10/ — wide and compact, light and dark, label grouping and the same workspaces under status grouping, plus the hover chevron swap, the glyph zooms, and a before/after pair taken with the fix reverted to the bug's shape. Co-authored-by: Christoph Leiter <christoph@leiter.io> * fix(app): align label chip typography Co-authored-by: Christoph Leiter <christoph@leiter.io> * docs: format architecture module table Co-authored-by: Christoph Leiter <christoph@leiter.io> * fix(app): narrow workspace labels workflow Co-authored-by: Christoph Leiter <christoph@leiter.io> * fix(app): mirror bottom sheet test exports Co-authored-by: Christoph Leiter <christoph@leiter.io> * test(desktop): assert project browse by destination Co-authored-by: Christoph Leiter <christoph@leiter.io> * fix(app): retain empty projects without label filters Co-authored-by: Christoph Leiter <christoph@leiter.io> * fix(app): preserve status grouping test contract Co-authored-by: Christoph Leiter <christoph@leiter.io> * fix(app): retain filters after label load failures Co-authored-by: Christoph Leiter <christoph@leiter.io> --------- Co-authored-by: Christoph Leiter <christoph@leiter.io>	2026-08-18 12:49:23 +00:00
Kevin Aspesiandpaseo-bot[bot]	429155b536	Add collapsed-project status badge to the sidebar (#2340) ... * Add collapsed-project status badge to the sidebar Collapsed project rows now surface the most urgent hidden workspace's status as a corner badge on the project icon, instead of giving no signal at all: a loader for running, an alert for needs_input, a dot for attention/failed, nothing for done. Priority order (needs_input > failed > running > attention > done) means a working project keeps its loader even if another workspace is also awaiting review. Every surfaced status shares one badge shell (size, ring, offset) so the loader, alert, and dot never draw a differently-sized circle - previously the loader/alert used a 12pt ring while the dot used a 7-9pt one with a different corner offset. The running loader is also nudged half a point left so its visual center lands on the circle's center rather than reading as shifted right. Adds an e2e capture spec (run on demand, not part of CI) that seeds every state and edge case through the mock provider and dumps DOM geometry, for re-verifying the badge shell stays uniform. * Add PR review gallery images for the status badge PR Temporary evidence assets for pull request review, embedded via blob URLs in the PR description. Safe to delete after merge. * Swap misleading before/after PR images for clean per-state stills This feature never shipped on main, so there is no real "before" to compare against for a reviewer — the earlier before/after images were an artifact of local dev iteration, not a regression fix. Replaced with one clean still per status. * Fatten needs-input alert and dot to fill the shared badge shell Lucide's circle-alert only paints ~83% of its nominal size, so the prior 10pt glyph read as smaller than the loader inside the same 14pt shell. Sized both up so all three glyphs draw the same visual footprint against the shared ring. * Address review: extract pure badge-content selection, drop JSDOM tests Greptile flagged getStatusDotColorStyle's needs_input/running cases as dead (unreachable — shouldRenderSyncedStatusLoader and an explicit check already intercept those buckets earlier). Extracting the selection logic into a plain-TS descriptor function (getProjectStatusBadgeContent) makes that structural: the "dot" variant is typed to failed|attention only, so there's no switch left with unreachable branches. That extraction also resolves the JSDOM component test Greptile flagged (project-leading-visual.test.tsx used vi.hoisted/vi.mock/ createRoot mounting, all banned by docs/testing.md's two test categories) — the pure selector is now tested directly with a plain vitest file, no mounting needed. Dropped that test file and use-sidebar-project-status-bucket.test.tsx (same banned pattern); the real coverage was already redundant with sidebar-workspaces-view-model .test.ts's existing priority-order assertions and the e2e capture spec's real-app gating checks. Also split a conditional branch in the e2e capture spec's assertion loop into two deterministic loops (badge-expected vs no-badge cases) per Greptile's third note. * Size status-badge glyphs even so they center in the shell The badge shell's interior is 12pt (14pt minus the 1pt ring on each side). A centered glyph of size N sits at a (12 - N) / 2 offset, which is fractional for odd N and gets snapped to a device-pixel boundary, rendering visibly off-center (~1.5 device px at 3x). Drop the dot to 8pt and the alert to 10pt so both divide the interior into whole pixels and land dead center; Lucide's circle-alert paints ~83% of nominal, so 10pt draws a ~8.3pt disc that matches the 8pt dot. Also extends the on-demand capture spec to cover the failed bucket, the priority aggregation cases, dark mode, hover, a compact viewport, and a recorded running-to-expand transition, dumping DOM geometry that proves every shell shares one size/offset and every even glyph centers at 0px. * Refresh status-badge PR assets for the even-glyph sizing Recaptures every state at the approved 8pt-dot / 10pt-alert sizing, adds the failed bucket to the per-status set, a crosshair sizing/ centering proof, dark-mode and compact-form-factor shots, and replaces the soft upscaled spinner GIF with a crisp one assembled from native 3x-scale frames. Drops the stale pre-sizing images. * Add capture spec proving workspace statuses roll up to the project badge Seeds three collapsed projects, each with several same-directory workspaces in different buckets, so each resolves to a different highest-priority winner (needs_input / failed / running). Films the collapse and expand so the aggregation is provable as motion, not a single frame. * Add propagation recording showing statuses resolving to the project badge * Add higher-quality mp4 of the status propagation recording * Refactor project status badge coverage --------- Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>	2026-08-02 00:37:22 +08:00
Mohamed Boudra	9d19e90323	Show worktree names in workspace hover cards (#2711) ... * fix(app): show worktree names in workspace hover cards Managed worktree paths exposed Paseo's internal directory layout instead of the useful worktree name. Carry the owned worktree root through the sidebar model while preserving the full workspace path as the copy target. * fix(workspaces): source owned worktree names from daemon The daemon owns worktree path semantics, so expose the managed worktree slug and let the sidebar model produce a display-ready label. This keeps path parsing out of the hover-card component while preserving the full path for copying. * fix(app): preserve worktree labels in replica cache	2026-08-01 05:17:47 +08:00
Mohamed Boudra	de44c8cd66	Show New Workspace isolation controls immediately (#2702) ... * fix(workspaces): show isolation without checkout delay * fix(workspaces): trust hydrated project capability * fix(workspaces): resolve branch before creation * fix(workspaces): honor invalidated checkout status * fix(workspaces): preserve isolation while projects load * fix(workspaces): keep provisional project routes usable Route-derived projects do not know their worktree capability. Represent that uncertainty at the placement boundary so remembered worktree intent survives hydration without disabling the New Workspace screen indefinitely.	2026-07-31 17:50:35 +02:00
Mohamed Boudra	99eca19a76	Keep selected projects when switching hosts (#2700) ... * fix(app): preserve project selection across hosts Rendered project identity and persisted equivalence were conflated after duplicate-project handling. Keep them separate so host changes resolve selectable equivalents deterministically without resetting legacy sidebar identity. * fix(app): restore selected clone after host round trip Keep manual origin and current destination placements separately so switching back restores the chosen checkout while archive gaps preserve the active host selection. * fix(app): key status icons by project view * fix(app): preserve origin during archive gaps	2026-07-31 15:42:08 +02:00
Mohamed Boudra	20e46e3e3f	Restore project grouping across hosts (#2565) ... * fix(projects): restore cross-host grouping Random host-local project IDs replaced the remote-derived value that had also served as grouping identity. Persist a separate opaque group key and let normal boot reconciliation backfill older records without a migration. * fix(projects): keep ambiguous clones separate A shared remote can identify a project across hosts, but it cannot distinguish two independent clones on one host. Treat those keys as ambiguous so host-local project IDs remain separate. * fix(projects): preserve host-local project identity * fix(projects): strengthen grouping identity * test(app): update project host shape contract * fix(projects): preserve selected host identity * fix(projects): close grouped routing gaps * fix(projects): stabilize legacy subproject grouping * fix(projects): preserve selected project identity * fix(projects): isolate legacy host identity * fix(projects): preserve symlinked bootstrap roots * fix(projects): reconcile grouped custom names * fix(projects): stabilize settings and path identity * fix(projects): normalize default remote ports * fix(projects): harden host and remote identity * fix(projects): preserve host-scoped actions * fix(projects): preserve remote path semantics * fix(projects): model SCP remote semantics * fix(projects): keep settings on routed host * fix(projects): preserve SSH URL path semantics * fix(projects): separate identity from presentation * test(projects): use grouped identity in UI specs * fix(projects): harden grouped project routing * test(projects): expect framed settings route * fix(projects): preserve exact placement identity * fix(projects): harden grouping identity and routing * fix(projects): restore project key as grouping identity Random host-local project IDs had replaced the persisted cross-host value carried by projectKey. Keep projectId for routing while reconciliation owns and persists projectKey for grouping. * fix(projects): prevent project key collisions Preserve platform path semantics and generic remote transports in cross-host keys, and compare legacy checkout roots using filesystem equivalence before materializing ownership. * test(projects): assert host-scoped project keys * fix(projects): preserve project key compatibility Resolve legacy workspace project references at the daemon boundary while keeping projectKey as the cross-host identity. Complete generic SSH normalization without collapsing distinct repositories. * fix(projects): harden project reference identity * fix(projects): retain archived reference errors * fix(projects): scope legacy paths to hosts * test(app): model persisted project keys * fix(projects): retain absolute scp users * fix(projects): resolve legacy mutation aliases * fix(projects): preserve conservative identity boundaries * fix(projects): preserve legacy placement identity * test(projects): assert legacy placement identity * test(projects): expect canonical Windows keys * fix(projects): separate bootstrap identity fields * fix(projects): scope legacy paths by host * fix(projects): stabilize opaque project identity * fix(projects): preserve remaining opaque identities * fix(projects): classify forward-slash UNC roots * fix(projects): preserve opaque selection keys * fix(projects): frame host-local project keys * fix(projects): canonicalize framed identities * test(projects): isolate repeated remote fixtures * fix(projects): keep project key as UI identity * fix(projects): reconcile hydrated project references * fix(projects): preserve archived project identity * refactor(projects): group projects from project records, not workspaces Cross-host grouping had been built by hanging a projectKey off every workspace descriptor. That scoped the key to the wrong entity: the app then had to reconstruct project identity per workspace in six modules, which forced projectKey fallbacks into RPC arguments and a server-side resolver that turned grouping keys back into project ids. A workspace has a projectId. The key belongs to the project, and grouping is a display concern, so the daemon now publishes projects over project.list plus the existing project.update channel and the app groups them in one place. Projects are addressed by host-local projectId everywhere, including the settings route. Projects persisted without a key are backfilled by ordinary boot reconciliation, with no migration. Old daemons advertise no projectList capability and simply do not group. * test(projects): seed projects alongside workspaces in fixtures Sidebar fixtures seeded workspaces without their projects, which the daemon cannot produce now that projects arrive on their own channel, so nothing rendered. Adds a seeding helper that supplies both. Also drops the provisioning test for accepting a project key where a project id belongs; that resolver was removed deliberately. * fix(projects): keep derived project identity stable Four gaps left by shrinking the key derivation: Local keys used a bare path resolve, so one directory reached by a different spelling produced a different key and reset grouped identity. Windows CI caught this with the 8.3 and long-name forms of one temp path. Canonicalize through the shared realpath-aware normalization. Subproject display names lost their selected-path input, so every subproject of a monorepo rendered under the same remote-derived name. Reconciliation only ever backfilled a missing key, so a project whose remote changed stayed grouped with hosts on the old remote. Project settings kept a disconnected host selected and rendered a dead end with no way back to an editable host. * fix(projects): read scheme remotes as URLs, not scp form An `ssh://user@host:22/org/repo` remote matched the scp-form pattern first, because `[^@]+` happily eats `ssh://git`, so the port landed in the path and the project keyed as `remote:host/22/org/repo`. Two spellings of one remote therefore never grouped. Try scp form only when there is no scheme, and drop protocol-default ports so an explicitly written `:22` matches the same remote without it.	2026-07-29 23:36:31 +02:00
Mohamed Boudra	9603397aed	perf(app): limit initial sidebar workspace rendering ... Large project, status, and pinned groups now render 20 rows until expanded. Newly discovered workspaces are prepended without disturbing the saved order.	2026-07-21 23:56:22 +02:00
nllptrxandMohamed Boudra	a8ebd390fa	feat(forge): pluggable forge abstraction + GitLab and Gitea/Forgejo/Codeberg (#1913) ... * refactor(forge): forge-neutral foundation (GitHub-only) Decouple git-hosting from GitHub behind a neutral abstraction (issue #1616), GitHub-only for now; existing GitHub behaviour is unchanged. - Forge manifest, neutral ForgeService contract, forge registry + resolver, and a client forge-module registry. - GitHub code renamed to the neutral shape; PR/Issue attachment wording preserved. - forge.search.response enums parse tolerantly (unknown kind/auth state degrade instead of breaking the client). - createPullRequest reports typed CLI/auth errors instead of a generic message. - forge-resolver host/remote caches are LRU-bounded. - Forge host trust is explicit: only a known cloud host or a CLI-authenticated host is ever talked to; an unauthenticated GitHub Enterprise host fails resolution instead of routing to github.com. - Docs: forge-providers guide, glossary and i18n forge-copy conventions, architecture and rpc-namespacing terminology. - Vitest React Native mocks (unistyles, svg, linking, lucide) consolidated into shared aliased test-stubs. * feat(forge): GitLab adapter, forge-aware UI, pipelines and approvals GitLab adapter over the glab CLI on the neutral contracts: MR status, forge-aware UI, pipeline tree, and N-of-M approvals. - threadIsResolved is part of the neutral timeline item. - Pipeline load failures show an error instead of an empty section. - Manual pipeline jobs render as pending. - Fork/detached MR head pipelines are fetched by MR iid (glab ci get --merge-request). * feat(forge): Gitea family adapter (Gitea, Forgejo, Codeberg) One adapter over the tea CLI serving Gitea, Forgejo, and Codeberg on the neutral contracts. - CI status aggregates commit statuses and Actions runs together. - Gitea's terminal "warning" state maps to failure on server and client. - Gitea Actions check details are reachable from the PR pane by workflowRunId. * refactor(forge): localize compatibility handling * test(forge): expect normalized GitLab facts --------- Co-authored-by: Mohamed Boudra <boudra.moha@gmail.com>	2026-07-17 15:03:26 +08:00
3 people	a1e81685a1	feat(app): pin chats to the top of the sidebar (#1981) ... * feat(app): pin projects to top of the sidebar Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(app): dedicated Pinned sidebar section with UX fixes Replaces the invisible float-in-place pinning with a Codex-style Pinned section at the top of the sidebar that hoists pinned chats and projects. - Pin-aware keyboard shortcut numbering (badges match visual order) - Pinned chats show their project name as subtitle (context after hoisting) - Pinned entries ordered most-recently-pinned first - Collapsible Pinned section (persisted) - Double-click guard on workspace pin toggle Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(app): move Pinned section above the Workspaces header Pinned now sits at the top of the scroll, above the "Workspaces" section header (which moves into the scroll below it), matching the market-standard sidebar layout. Chevron sits beside the "Pinned" label. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(app): reveal Pinned collapse chevron on hover only Extracts PinnedSectionHeader with its own hover state; the chevron hides until hover on web and stays visible on touch/compact. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(app): pin the active chat via keyboard shortcut and inline pin button Adds a ⌘⇧P / Ctrl+Shift+P shortcut that pins the selected chat, mirroring the worktree.archive action across actions/dispatcher/route-shortcut, gated by `selected && supportsWorkspacePinning`. Also surfaces an inline pin button on row hover (always-on for touch) alongside the kebab in the shared trailing overlay, swapping Pin/PinOff by pinned state. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * refactor(server): unify project and workspace pin handlers Collapses the two near-identical pin.set handlers into a shared handlePinSetRequest that owns control flow, error handling and the workspace-update fan-out; each caller only supplies its registry apply step and typed response payload. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(app): drop empty pinned project shells and empty Workspaces header Pinning every chat of a project hoisted them into Pinned but left an empty project header (plus its new-workspace ghost row) below, duplicating the project. Skip projects emptied by pinning while keeping genuinely empty projects. Also hide the "Workspaces" section header when no unpinned projects remain, so it no longer floats above nothing. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(protocol): correct workspacePinning COMPAT version to v0.1.105 Feature ships in 0.1.105 per the changelog, not the placeholder v0.1.103. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(app): hide redundant chat pin control inside pinned projects A pinned project already hoists all its chats to the top, so the per-chat pin was a no-op that just toggled a dead icon. Suppress the inline pin button, the kebab pin item, and the pin keyboard shortcut on chats whose project is pinned; they still work for chats in unpinned projects. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(app): hide project pin control on empty projects Project pin state is derived from workspace descriptors, so a project with no workspaces would set pinnedAt on the server but emit no descriptor update — the pin silently never surfaced and the user got no feedback. Offer the pin only once the project has a chat, matching how chat pins are suppressed inside already-pinned projects. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(app): drop collapsed Pinned rows from keyboard shortcut numbering When the Pinned section is collapsed its chats and projects are hidden, but the shortcut model kept counting them: visible unpinned rows showed off-by-N badge numbers and pressing a number key jumped to a hidden pinned chat. Exclude the pinned rows from numbering when Pinned is collapsed, matching what renders. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(app): hydrate pinned sidebar rows * fix(app): keep filtered workspace controls reachable * feat(app): scope sidebar pinning to chats, drop project pinning Per PR review: pinning whole projects overlapped with project reordering and mixed projects into the pinned list. Keep chat pinning only. - Remove the project.pin.set RPC, its server handler, the projectPinnedAt descriptor field, and the client setProjectPinned method. - Drop the project pin control, isProjectPinned reads, and the suppressPin plumbing (its only source — a pinned project — is gone). - Fold pin-aware shortcut ordering into SidebarModelProvider (the live shortcut owner) and delete the orphaned use-sidebar-shortcut-model hook, so pinned chats and their shortcut numbers share one projection. - Prune the now-unused project pin i18n keys across all locales. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * refactor(server): inline the pin handler into the workspace path With project pinning gone, handlePinSetRequest had a single caller. Fold it back into handleWorkspacePinSetRequest and drop the project/workspace generalization. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * revert: keep main's use-sidebar-shortcut-model untouched This hook (and its test) already live on main. The scope-down had deleted them, but that's out of scope for this PR — the pin-aware shortcut ordering lives in SidebarModelProvider now, so main's hook is left exactly as it was. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * chore(protocol): align workspacePinning COMPAT version in websocket-server Match the v0.1.105 version already corrected in messages.ts. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(app): reshape pinned sidebar updates * chore(app): remove stale pin button styles * refactor(app): simplify pinned workspace rows --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: Mohamed Boudra <boudra.moha@gmail.com>	2026-07-13 10:59:02 +02:00
Mohamed Boudra	28a27b02d3	Prevent Android chats from freezing or going blank (#1989) ... * fix(app): stabilize streamed chat rendering Use deterministic Markdown AST keys and preserve unique row identities when an assistant message resumes after a tool. Keep native gesture and plan-card children correctly keyed to avoid unsupported Fabric reconciliation paths. * fix(app): stabilize retained native panels Keep retained workspace roots in a stable native order and make active panels present in the selection commit. Hidden panels now stop expensive subscriptions and animations without losing mounted state. * fix(app): harden retained panel activity	2026-07-11 15:39:14 +08:00
Mohamed Boudra	a743a22496	Keep large sidebars responsive (#1966) ... * perf(app): keep large sidebars responsive Sidebar rows rescanned every agent for each session update, multiplying work with both workspace and agent count. Build workspace activity once and share the derived sidebar model so updates scale with the underlying collections. * test(app): use valid agent fixture for workspace restore * refactor(app): keep sidebar model surface focused	2026-07-10 06:12:56 +08:00
Mohamed Boudra	9b6aa99396	feat(sidebar): show host name on every row in multi-host setups (#1775) ... The host name previously appeared only in project grouping mode, and only for projects shared across hosts. It now shows on every workspace row in both project and status grouping modes whenever the sidebar spans more than one host, so you can always tell which machine a workspace lives on. Status rows read "Project · Host". Single-host setups are unchanged.	2026-06-28 08:50:04 +07:00
Mohamed Boudra	a49c658d1f	Merge sidebar workspaces across all connected hosts (#1538) ... * Merge workspaces across all hosts in the sidebar Replace per-host sidebar sections with a single merged project list. Projects that exist on multiple hosts (matched by projectKey) are collapsed into one row. Host identity is surfaced via: - A status-only footer pill showing online/offline host counts - Hover cards with a mandatory host row on every workspace entry - Subtitles showing the host name when a project spans >1 host - A host filter in the grouping dropdown (not a sidebar switcher) Order and group-mode stores migrated from per-server to global keys with zustand persist migrations. New-workspace screen now shows a merged project list with a host selector combobox. Key files: - workspace-structure.ts: merge algorithm by projectKey - sidebar-view-store.ts / sidebar-order-store.ts: global state - sidebar-workspace-list.tsx: context-based subtitle injection - new-workspace-screen.tsx: host selector in footer row * Add host filtering to the merged sidebar The sidebar now merges workspaces from every connected host, so a single global "active host" no longer fits. Host selection becomes explicit per action via a host chooser, and agent history pages across all hosts at once. Removes the active-host / active-server-id model and the all-agents-list hook that fed it. * Fix rebase fallout: translate archive host error, update stale workspace-key test archiveWorkspacesOptimistically used a raw "Host is not connected" string that the i18n completeness test forbids; route it through i18n.t with the existing hostDisconnected key. The selectors memoization test asserted un-prefixed workspace keys, but merged-sidebar keys are serverId-prefixed. * Fix sidebar review fallout * Address sidebar review followups * Fix sidebar workspace identity migration * Address sidebar review followups * Handle partial host history failures * Fix merged sidebar project removal and E2E drift * Restore history routes and project removal shape * Remove sidebar host context plumbing * Tighten sidebar status and host filter state * Keep new workspace project selection host-compatible * Migrate sidebar view storage * Streamline host selection flows * Update all-host history on archive * Fix empty project sidebar action Code regression: the main merge dropped the empty-project New workspace child row while keeping the empty project persistence contract. Restore the row using the project host target so the sidebar stays aligned with the no-host-selection model. * Fix Japanese shortcut translation key Stale-base integration: main added the Japanese locale after this branch added cycleAgentMode to the English shortcut help map. Merging main exposed the missing ja key in CI typecheck and resources.test. * Fix Playwright speech teardown race	2026-06-26 12:16:49 +08:00
Mohamed Boudra	71b5c35d9b	Run multiple independent workspaces per directory (#1539) ... * feat(workspace): bind agents/terminals/status to workspaceId (Model B phase 1) Model B EX-Phase 1: the binding layer. Records gain an additive workspaceId that answers "which workspace does this belong to" without replacing the existing required cwd. - protocol: add optional workspaceId to agent/terminal records and a workspaceOwnership capability under server_info.features.* - server: resolve and persist workspaceId on agent and terminal creation; carry it through agent-manager, projections, storage, loading, sessions, and the terminal manager/worker pipeline - workspace-directory / workspace-registry-model: derive and expose workspace ownership; bind status to workspaceId - client: surface workspaceId via daemon-client - app: filter terminals and agent visibility by workspaceId, thread it through workspace screen / terminal panel / session store - tests: cover workspaceId binding across create, agent-manager, mcp-server, workspace-directory, workspace-registry-model, and agent-visibility cwd stays required on every record; workspaceId is purely additive and back-compatible (optional/defaulted), so old and new peers still parse each other's messages. Known follow-ups: none. * feat(workspace): empty projects + editable titles, fix same-cwd terminal isolation (Model B phase 2) - Address Phase 1 review fixes and add same-cwd terminal isolation e2e coverage - Isolate terminal subscriptions per workspaceId so two workspaces sharing one cwd no longer cross-wire terminals (terminal-subscription-key) - Add editable workspace title, decoupled from the backing directory/branch - Persist empty projects (no workspaces yet) across daemon restarts - Add e2e coverage: empty-project-persists (server + app), workspace-same-cwd-isolation, sidebar-workspace-rename Known follow-ups: none * feat(workspace): create multiple workspaces per directory — local or worktree (Model B phase 3) - workspace.create RPC always creates a new workspace record; no directory dedup - dropped directory dedup in open_project and createPaseoWorktree paths - non-git directories are first-class: local-checkout workspaces no longer require a repo - service-proxy collision resolved by defaulting to the owning workspace instead of failing - new creation UI: choose backing directory (local checkout or worktree) per workspace - e2e coverage for creating multiple workspaces over the same directory Known follow-ups: - COMPAT cwd->workspaceId resolver remains until client floor advances - prune any remaining workspace==directory assumptions surfaced by usage * feat(cli): paseo run workspace policy — bare run creates a workspace, --workspace/PASEO_WORKSPACE_ID target (Model B phase 4) - A workspace is now the explicit home of a `paseo run`: run.ts resolves a workspace before creating any agent, then stamps the agent with that workspaceId — no run leans on createAgent's legacy cwd->workspace fallback. - Precedence: --workspace <id> > $PASEO_WORKSPACE_ID > --worktree > bare run. --worktree mints its own workspace and overrides the ambient PASEO_WORKSPACE_ID; --worktree + --workspace is rejected upstream. - New-workspace-per-bare-run: every bare run mints a fresh local-backed workspace for its cwd rather than reattaching to an existing one in that dir. - Env support: $PASEO_WORKSPACE_ID (exported by workspace terminals) targets an existing workspace, same as --workspace. - Help text: new --workspace option documents the default (new workspace per run) and the env fallback; created runs print the workspace id plus a tip. - e2e: cli-run-workspace-precedence.e2e.test.ts covers bare, distinct-per-cwd, --workspace attach, and env attach against an isolated daemon. Known follow-ups: - createAgent's COMPAT cwd->workspace resolver stays for old clients; the CLI no longer relies on it but it is not yet removable. * feat(workspace): archive removes the workspace record, never the directory; last worktree ref offers disk delete (Model B phase 5) - Archive is now scoped to a single workspace RECORD (by workspaceId), not by cwd/worktree path. It tears down only the agents and terminals owned by the target workspaceId. - Sibling isolation: a directory can back multiple workspaces, so archiving one workspace no longer destroys a sibling workspace's agents, terminals, or directory. - Decoupled on-disk worktree deletion into an explicit, last-reference-only option (deleteWorktreeFromDisk). The directory is removed only when the archived workspace was the last active reference to a Paseo-owned worktree; local checkouts are never deleted. - Unified archive UI with a keep/delete prompt: "Keep on disk" is the default non-destructive choice, "Delete" removes the worktree directory. - Protocol: new optional, defaulted deleteWorktreeFromDisk field (COMPAT-tagged, back-compat preserved). - Tests: record-scoped archive e2e (sibling isolation, last-ref disk delete, sibling-keeps-directory) and an app e2e for the keep prompt. Known follow-ups: - Surface the keep/delete prompt's "delete" path coverage in app e2e (only the keep path is exercised today). - COMPAT(worktreeDiskDeletion): drop the optional gate when floor >= v0.1.97. * feat(workspace): uniform expandable projects + status inbox; merged worktrees cleaned, explicit-id archive (Model B phase 6) - P5 archive fixes: worktree archive now targets an explicit workspaceId, and auto-archive-on-merge cleans the worktree directory from disk when it is the last reference. - Dropped non-git project flattening: every project — git or non-git, single- or multi-workspace — renders as the same expandable parent. - Every project is expandable and every workspace is archivable; each carries its own "+ New workspace" affordance regardless of kind. - Added a status inbox grouping (Ready for review / Working / Done) where each workspace is bucketed independently by last update. - The deepest sidebar level is the workspace row: tabs, agents, and terminals never appear in the sidebar. - Added Model B sidebar e2e coverage proving the expandable-parent, no-leaf, and independent-status-bucketing invariants. Known follow-ups: the inline header FolderPlus worktree shortcut stays git-only (canCreateWorktreeForProjectKind); non-git projects create workspaces via the "+ New workspace" row. * fix(protocol): use literal :: separator in terminal subscription key The committed blob contained a NUL byte as the separator instead of the :: the comment documents, which broke text diffs and review tooling (git flagged the file as binary). Functionally the key is an in-memory Map key only, but source must stay text. * feat(workspace): shared directory right-sidebar boundary + docs; final consolidation (Model B phase 7) - Pin and document the directory-backed vs workspace-owned right-sidebar boundary: same-cwd workspaces share directory-keyed git/PR/file surfaces but never share workspace-owned drafts, attachments, or file-explorer state. New docs section in architecture.md plus data-model.md keying convention and two glossary terms. - Add e2e coverage for the boundary: same-directory-workspaces.spec.ts proves the right sidebar is shared (a directory change appears in both same-dir workspaces) while tabs/terminals stay independent per workspace. - Accumulated follow-up fixes: - MCP child agents created in a new worktree are stamped with the new worktree's workspaceId (not the parent's, not unstamped), mirroring the session path so workspaceId-scoped archive can find and tear them down. - session-store mergeWorkspaces prunes a stale empty-project descriptor when a workspace lands in that project, so it stops governing the project's metadata. - CLI run: reject --worktree alongside an ambient PASEO_WORKSPACE_ID (not just --workspace), so worktree resolution never races an existing-workspace select. New run.test.ts pins the three validation outcomes. - Full-branch reshape outcomes: - Consolidate the four placeholder server_info.features flags (workspaceOwnership, workspaceTitles, workspaceProjects, workspaceMultiplicity) into the single workspaceMultiplicity capability gate. - Remove the now-dead ensureLocalCheckoutWorkspace and its deps interface; explicit creation always mints a new same-cwd record via createLocalCheckoutWorkspace. - Resolve every Model B COMPAT marker from v0.1.X to v0.1.97. - Drop the obsolete workspaceOwnership feature assertion from the same-cwd isolation e2e; broaden a sidebar-shortcuts test to cover both project kinds. - Add workspace-create-errors.e2e.test.ts pinning each early-reject error branch. - typecheck, lint, format all green. Known follow-ups: pre-existing COMPAT(rewind) markers still carry v0.1.X placeholders (out of Model B scope, left untouched). * test(workspace): de-slop Model B tests per audit-tests (reshape mocks/assertions) Reshape Model B test changes flagged by audit-tests so they exercise real behavior and observable state instead of mock scaffolding. Categories fixed: - Mocks -> real dependencies + persisted state: create.test.ts and mcp-server.test.ts dropped hand-built AgentManager/AgentStorage mock objects and mock.calls[...] assertions, now run the real AgentManager/AgentStorage with a fake agent client and assert on the stored agent record (workspaceId, parent label). - Module-internal spying -> injected seam: acp-agent stopped spying on the tree-kill module (vi.spyOn(treeKillModule, ...)). Added a ProcessTerminator injection seam to ACPAgentClient/ACPAgentSession (production defaults to terminateWithTreeKill); tests inject a typed FakeTerminator and assert on the recorded children plus observable stream .destroyed state. - Poking internals -> public API: acp close()/killTerminal/releaseTerminal tests now create terminals through the public createTerminal API instead of mutating internals.terminalEntries. - Reimplemented production logic deleted: cli-run-workspace-precedence dropped its inline copy of resolveRunWorkspace flag precedence (a fake reimplementation it then asserted against) and now proves only the daemon behaviors the CLI builds on; flag precedence stays covered in the CLI's own run.test.ts. - Sleep -> poll: workspace-same-cwd-isolation replaced a fixed setTimeout with expect.poll on the observed snapshot state to remove the race. - Internal protocol-frame assertions removed: sidebar-workspace-rename dropped the captureWsSessionFrames workspace.title.set.request assertions, relying on the user-visible rename + reload checks already present. * fix: green CI — new-workspace status bucket regression + branch-picker flow tests + sdk emptyProjects Source regression: - packages/app/src/screens/new-workspace-screen.tsx - packages/app/src/screens/new-workspace-empty.ts When a new workspace is created with an initial agent, optimistically merge it with status "running" (statusEnteredAt now) so it lands in the "Working" bucket instead of defaulting into the wrong bucket. The empty-workspace path passes withInitialAgent: false so a bare workspace keeps its descriptor status. Test-drift (intentional P3 flow change — backing picker now required): - packages/app/e2e/new-workspace.spec.ts - packages/app/e2e/helpers/new-workspace.ts The reshaped creation flow requires choosing a backing ("New worktree") before the branch / starting-ref picker is reachable. Branch-picker specs now call selectWorkspaceBacking(page, "worktree") first, and the helper waits for the worktree control to drop aria-disabled (it stays disabled until the checkout status query confirms the project is a git repo) before clicking. Test-drift (protocol field added — sdk emptyProjects): - packages/client/src/index.test.ts fetch_workspaces response now carries emptyProjects; the toEqual expectation includes emptyProjects: []. Flake hardening: - packages/app/e2e/same-directory-workspaces.spec.ts - packages/app/e2e/helpers/seed-client.ts Out-of-band working-tree writes raced the daemon's debounced filesystem watcher, so the UI could subscribe before the new file was in the git snapshot. Force a checkout refresh (same path as the UI's manual refresh) to make the write authoritative before asserting, removing the timing dependency. * test(app): expect withInitialAgent:false in empty-workspace create call The withInitialAgent flag (fix for the new-workspace Done-bucket regression) added a field to the ensureWorkspace call; the empty-path unit test pinned the exact args. Test-drift, not behavior — update the expectation. * feat(app): stack new-workspace creation params (Project / Isolation dropdown / Base) with reserved base row + keyboard avoidance Restructure the new-workspace creation screen into a vertical stack of Project / Isolation / Base parameters instead of the previous mixed layout. - Isolation/backing is now a dropdown (Local vs New worktree) matching the app's existing dropdown/combobox primitives, replacing the inline segmented switcher. - The Base (starting ref) row now reserves its space even when the backing is Local and the picker is hidden, so switching backing no longer causes the form to shift vertically. - The form avoids the keyboard so the title input and submit stay visible while typing on native and web. - Updated the e2e new-workspace helper to drive the dropdown-based backing selector and the reserved Base row. * fix(app): simplify new-workspace form — stacked ghost rows above composer, no card/title, project-matched dropdowns - Render the three rows (formStack) at the top, under the "New workspace" heading and above the composer input, not in the composer footer. - Drop the card/surface/border chrome; rows sit on the plain background. - Stack Project, Isolation (multiplicity only), and Base; remove the title field — the title is set server-side and create works with no user title. - Each row is a Label immediately followed by its dropdown control; no columns, fixed label widths, or reserved horizontal space, with the label glyph aligned to the heading's text x. - All three triggers share the ghost badge style of the Project control (ProjectPickerTrigger / IsolationPickerTrigger / RefPickerTrigger + Combobox); keep the workspace-create-backing-* test IDs. - Omit "New worktree" from Isolation entirely when the project is non-git. - Reserve the Base row height always but render nothing on Local backing, showing the Base label + ref picker only for New worktree. - Keep keyboard avoidance on the centered content. - E2E: drive selectWorkspaceBacking via the Isolation trigger + Combobox and remove the now-gone workspace-create-title-input usage and title field. * feat(app): sidebar new-workspace entry points + non-git isolation hidden + project auto-select - Q1: hide the Isolation control on non-git projects — gate the row on canCreateWorktree (multiplicity && selectedIsGit) so a project with no git checkout never offers a worktree backing choice. - Q2: reset the stale project preselect across the reused 'new' screen — clear the manual picker choice on route project identity change so each route-driven navigation preselects its own project; align the nav verb to router.navigate. - Q3: remove the per-project "+ New workspace" sidebar row and add one global "New workspace" entry above Sessions in both mobile and desktop sidebars (testID sidebar-global-new-workspace); creation stays reachable per-project via the existing git new-worktree icon. - Q4: match the Sessions / New-workspace header button sizing to the workspace rows — SidebarHeaderRow icon md->sm, label fontSize base->sm. - e2e: new new-workspace-entry.spec covering global entry, project preselect reset across reused screen, and non-git isolation hidden; update sidebar-model-b, empty-project-persists, workspace-multiplicity, and helpers for the removed per-project row. * fix(app): group New-workspace/Sessions header (no divider, workspace-row sized) + remove banned useUnistyles - Q5: wrap the New-workspace and Sessions header entries in a single sidebarHeaderGroup that owns one bottom divider, so the two rows sit tight together with no gap and no per-row separator (both mobile and desktop sidebars). - Add a compact variant to SidebarHeaderRow: workspace-row sized (minHeight 36, surfaceSidebarHover, borderRadius.lg) with horizontal padding that aligns its icon/label with the Workspaces section title and the workspace rows below; the default header variant (settings Back-to-workspace) keeps its sidebar-height row and own separator. - Remove the banned useUnistyles() from sidebar-header-row.tsx per docs/unistyles.md: theme-reactive icon color now goes through withUnistyles(Icon) + uniProps mappings; static sizing reads ICON_SIZE. - Taste: new-workspace-screen dedupes the project-icon styles (single projectIcon/projectIconFallback/projectIconFallbackText) and replaces repeated magic numbers with BADGE_HEIGHT and a named fallback-font-size constant. * fix(app): no layout shift on git<->non-git (reserve Isolation row) + symmetric sidebar divider spacing - Q6: Isolation row reserves its height and renders an invisible spacer for non-git projects, matching the Base-row pattern, so switching between git and non-git projects keeps a constant form height with no layout shift. - Q7: sidebar header group splits paddingVertical into paddingTop/paddingBottom so the Sessions-row-to-divider gap equals the divider-to-Workspaces-header gap, centering the divider. * feat(app): rename Sessions to History (clock icon, Agent history header) - Sidebar label now reads "History" with a clock icon (was Sessions / MessagesSquare) - Sessions screen header now reads "Agent history" - Updated i18n strings across all 6 locales (en, ar, ru, zh-CN, fr, es) - Route and testIDs unchanged (sidebar-sessions, /sessions) * fix(app): symmetric sidebar header padding (top == bottom), traffic-light inset preserved The sidebarHeaderGroup wrapper (New-workspace + History rows) had paddingTop: theme.spacing[1] against paddingBottom: theme.spacing[2]. Equalize paddingTop to theme.spacing[2] so the header group's top padding matches its bottom padding. The divider stays centered since paddingBottom still matches WorkspacesSectionHeader's paddingTop. The desktop window-controls (traffic-light) spacer — paddingTopSpacerStyle plus TitlebarDragRegion — is a separate inset and is left untouched. * fix(app): hover card shows branch; sidebar copy-branch copies the real branch (not the title) - Add SidebarWorkspaceEntry.currentBranch, sourced from gitRuntime.currentBranch (normalized; detached HEAD/blank/missing -> null) - Fix copy-branch smear: handleCopyBranchName copied workspace.name (the title); now copies the real currentBranch (guarded) - Workspace hover card: add a branch row (GitBranch icon + branch name), shown only when it differs from the title - Header branch-switcher left untouched; diff-pane re-home decision still pending * feat(app): branch switcher moves into the git diff panel; header title is static (Model B coherence) - branch switcher now lives in the diff panel Changes header on desktop+mobile - workspace header title is a plain static title; branch removed from it - no new workspace-screen header row - git diff-stat unchanged, stays where it is - no duplicate git actions - unified descriptor name fallbacks via resolveWorkspaceName - rename-then-switch e2e proves header title and real branch stay independent	2026-06-15 14:23:02 +08:00
Mohamed Boudra	21deb08673	Make workspace IDs opaque, independent of the filesystem path (#1503) ... * Make workspace IDs opaque, independent of the filesystem path Workspace IDs were the resolved checkout/worktree path, so code could treat an ID as a path: prefix matching, deriving directories from it, falling back to a path when a lookup missed. IDs are now opaque - compared only by exact equality and never used as a path. Anything path-shaped resolves the workspace record first and reads its cwd. New workspaces get a generated `wks_` ID; existing path-shaped IDs are read from disk and never regenerated, so there is no migration and no change to the wire or persisted schemas. Groundwork for running multiple workspaces in a single directory. * Keep attachment scope key stable and align refetch test The attachment scope key keeps `workspace=` instead of `wsid=` so existing persisted drafts are not orphaned; the rename was cosmetic. The SDK refetch test no longer asserts a filter, matching refetch fetching one page and selecting by id client-side. * Fix live agent updates in directories without a registered workspace The opaque-ID work removed buildProjectPlacementForCwd's directory fallback, so an agent running in a folder with no registered workspace (e.g. a fresh non-git dir) produced a null placement. forwardAgentUpdate then threw "Workspace not found", the error was swallowed by its catch, and no agent_update was emitted — live model/thinking switches and status updates silently stopped. Caught by the live-preferences e2e suite. The fallback builds a directory-scoped project placement keyed by the path. That key is a project grouping key (non-git projects group by path), not a workspace id, so it stays within the opaque-id rule. * Always run server worktree archive, even without a resolved workspace Archiving bailed out entirely when the workspace was not found in the client store, so a race or stale state could make "archive" do nothing server-side with only a console.warn. The server archive is keyed by worktreePath, which is always available, so it now runs regardless; only the optimistic client-side updates (keyed by workspace id) are gated on the workspace being resolved. * Expect a directory-scoped placement for unregistered agent dirs This unit test asserted the no-placement behavior reverted in the live agent-update fix, which had broken live model/thinking switching. Update it to expect the directory-scoped placement now emitted for an agent in a directory with no registered workspace. * Fix opaque workspace routing in app E2E * Preserve workspace IDs during partial bootstrap * Fix archive flows for opaque workspace IDs * Stop treating opaque workspace IDs as filesystem paths Workspace IDs are opaque (wks_<hex>), but several call sites still passed the id where a directory was expected, which broke those flows for opaque IDs. The branch switcher sent the id as a cwd to branch/stash/checkout git operations, and server archive/reconcile cleanup keyed git-watch and subscription teardown by id, leaking that state. Git and filesystem operations now take the workspace directory; the opaque id is used only for identity and cache keys. Archive/reconcile cleanup routes through a single teardownArchivedWorkspace helper that keeps the key split explicit: runtime store by id, git watch and subscription by cwd. Path-derived grouping keys are renamed to directory keys, and the helpers are split into workspace-identity and workspace-directory so the id-vs-path boundary is obvious.	2026-06-14 22:03:27 +08:00
Mohamed Boudra	38f8179bc1	Add a global New workspace picker (#1324) ... * Add global New workspace project picker * Clean up New workspace picker state	2026-06-04 15:16:41 +08:00
Mohamed Boudra	31ae545289	Group and clear workspace status in the sidebar (#1317) ... * Add status grouping to the workspace sidebar * Mark workspaces as read from the sidebar * Clean package builds before release checks * Fix sidebar status follow-up checks	2026-06-04 01:20:20 +08:00
Mohamed Boudra	3ac182cffc	Improve app tests (#1197) ... * docs(testing): require ports-and-adapters unit tests or real e2e — no in-between State the end-state explicitly so the test-suite cleanup has a written bar. * Make useProjects a ports-and-adapters unit test Extract the per-host workspace aggregation out of useProjects into a pure fetchAggregatedProjects(input) that takes a typed ProjectsRuntime adapter. The hook becomes a thin useQuery shim. The test loses jsdom, @testing-library/react, QueryClientProvider, and all vi.mock/vi.hoisted of @/runtime/host-runtime. It now exercises the real aggregation against an in-memory ProjectsRuntime adapter. * Make useLoadOlderAgentHistory a ports-and-adapters unit test Extract the load-older sequence into a pure async function that takes its client, in-flight tracker, toast, and logger as injected dependencies. The hook reads the session store at call time and wires the real adapters in. Tests now drive the pure function with typed fakes — no JSDOM, no @testing-library/react renderHook, no console spy. * Make useAgentHistory a ports-and-adapters unit test Drop the dead __private__ namespace from use-agent-history.ts, expose fetchAgentHistoryPage and an AgentHistoryClient port as normal exports. The hook keeps its useInfiniteQuery wiring; the page fetcher is now testable in isolation. The test loses jsdom, @testing-library/react, QueryClientProvider, the vi.hoisted/vi.mock of @/runtime/host-runtime, and the renderHook timing loops. It exercises the page fetcher directly against an in-memory AgentHistoryClient adapter that records each call. * Make usePrPaneData a ports-and-adapters unit test Extract the timeline fetch into a pure fetchPrPaneTimelinePage that takes a PrPaneTimelineClient adapter and an UnsupportedTimelineRegistry port. Extract the rest of the hook's wiring into pure exports: extractPrRepoIdentity, shouldFetchTimelineFrom, selectPrPaneState. The module-level unsupported-tuple Set becomes a swappable in-memory registry; production still wires the same module-level default. The test loses JSDOM, vi.hoisted + vi.mock of @/runtime/host-runtime, QueryClientProvider, createRoot, act, focusManager/onlineManager toggling, and a hand-rolled waitForExpectation polling loop. It drives each pure function and the timeline fetcher directly against typed fakes and asserts on recorded state. * Make useProvidersSnapshot a ports-and-adapters unit test Extract the network and cache work into pure functions taking a typed ProvidersSnapshotClient adapter: fetchProvidersSnapshot, refreshAndApplyProvidersSnapshot, applyProvidersSnapshotUpdate, and selectorOpenRefetchDecision. The hook still drives them through react-query and the host-runtime websocket subscription; production wires the same DaemonClient as before. The test loses @vitest-environment jsdom, vi.hoisted + vi.mock of @/runtime/host-runtime, renderHook + QueryClientProvider, act, and a hand-rolled listener-bucket trap that reached into the spied client.on subscriber. It drives each pure function directly against a typed FakeProvidersSnapshotClient and a real QueryClient. * Make useSettings a ports-and-adapters unit test Extract the pure load/save logic into use-settings.pure.ts taking a typed SettingsDeps adapter: a KeyValueStorage port and a DesktopSettingsBridge port. The hook file keeps the public 0-arg API (loadAppSettingsFromStorage, loadSettingsFromStorage, persistAppSettings, saveAppSettings) by wrapping the pure functions with productionDeps that wire AsyncStorage, isElectronRuntime, loadDesktopSettings, and migrateLegacyDesktopSettings as before. The test loses three vi.mock blocks (async-storage, @/desktop/host, @/desktop/settings/desktop-settings), two vi.hoisted blobs, and the vi.resetModules + await import("./use-settings") per-test pattern. It drives the pure functions directly against an in-memory InMemoryKeyValueStorage and a FakeDesktopBridge that records applied migrations, asserting on observable storage state rather than mock function calls. * Make useAgentCommandsQuery a ports-and-adapters unit test Extract the daemon call into fetchAgentCommands, a pure async function taking a typed AgentCommandsClient adapter. The hook still wraps it in useQuery and resolves the host-runtime client; production wires the same DaemonClient as before. The test loses @vitest-environment jsdom, vi.hoisted + vi.mock of @/runtime/host-runtime, renderHook + QueryClientProvider, and waitFor. It calls fetchAgentCommands directly against a typed FakeAgentCommandsClient. * Make useChangesPreferences a ports-and-adapters unit test Extract the AsyncStorage-touching load and save logic into use-changes-preferences.pure.ts taking a typed KeyValueStorage adapter. The hook file keeps the public API (useChangesPreferences, loadChangesPreferencesFromStorage) by wrapping the pure functions with a productionStorage wired to AsyncStorage as before. The test loses vi.hoisted + vi.mock of @react-native-async-storage/async-storage, vi.resetModules, and the per-test dynamic await import("./use-changes-preferences") pattern. It drives the pure functions directly against an in-memory InMemoryKeyValueStorage, asserting on observable storage entries rather than mock function calls. Adds coverage for saveChangesPreferences, including the no-prior-cache fallback path. * Make useArchiveAgent a ports-and-adapters unit test Extract the queryClient-only pure helpers (toArchiveKey, selectPendingArchiveAgentIds, setAgentArchiving, isAgentArchiving, removeAgentFromListPayload, markAgentArchivedInHistoryPayload, and the queryClient-mutating cache helpers) into use-archive-agent.pure.ts. The hook file keeps the React surface (usePendingArchiveAgentIds, useArchiveAgent, applyArchivedAgentCloseResults) by importing from the pure module, and the __private__ reach-around export is gone. The test loses @vitest-environment jsdom, @testing-library/react, the renderHook/act/waitFor imports, and the __private__ reach-around. It calls the pure helpers directly against a real QueryClient and the real session store. The renderHook test of usePendingArchiveAgentIds is dropped — it asserted on react-query's subscription mechanics rather than on our logic. * Make useSidebarWorkspacesList a ports-and-adapters unit test Extract the pure pieces — types, applyStoredOrdering, appendMissingOrderKeys, buildSidebarProjectsFromStructure, and the new computeSidebarOrderUpdates + deriveSidebarLoadingState helpers — into use-sidebar-workspaces-list.pure.ts. The hook reads its persistent sidebar order via the pure helper inside useEffect and derives its loading state via the pure helper, instead of inlining the logic across two effects. createSidebarWorkspaceEntry stays in the hook file since it pulls selectPrHintFromStatus, but the hook re-exports it for existing callers. The test loses @vitest-environment jsdom, react-dom/client, @testing-library/react, and the three Probe components that mounted React just to assert on effect mechanics. It calls computeSidebarOrderUpdates and deriveSidebarLoadingState directly, with no module mocks or hoisted globals. The "does not subscribe while disabled" assertion is dropped — it was testing useSyncExternalStore's subscribe gate, not our logic. * Make useAgentInitialization a ports-and-adapters unit test Extract ensureAgentIsInitialized and refreshAgent — the entire imperative bodies of the hook's two callbacks — into use-agent-initialization.pure.ts, taking setAgentInitializing as an injected port. Add createSetAgentInitializing as a factory that binds serverId to the zustand setInitializingAgents action. The hook itself collapses to ~20 lines of useMemo + useCallback bindings. The test drops @vitest-environment jsdom, @testing-library/react, renderHook, and act. It calls ensureAgentIsInitialized and refreshAgent directly with a bound setAgentInitializing fake. No React mounting, no module mocks, no hoisted globals. * Make useClientActivity a ports-and-adapters unit test Extract the activity-tracker state machine — lastActivityAt bookkeeping, heartbeat throttling, app-visibility transitions, system-idle monotonic update, and focused-agent change handling — into use-client-activity.pure.ts. createClientActivityTracker takes the heartbeat client, deviceType, and a now() port; the hook wires DOM / AppState / Electron-idle listeners to tracker methods. The test drops @vitest-environment jsdom, react-dom/client mounting, act, and four module mocks (@/constants/platform, @/desktop/electron/idle, react-native, @getpaseo/client/internal/daemon-client). It calls the tracker directly with a fake heartbeat client and a test clock; the fake records emitted heartbeats as observable state. * Make useHoverSafeZone a ports-and-adapters unit test Extract the safe-zone state machine — wasInside dedupe, bridge-rect geometry between trigger and content, and inside/outside transitions — into use-hover-safe-zone.pure.ts. createHoverSafeZoneTracker takes getTriggerRect / getContentRect / onEnterSafeZone / onLeaveSafeZone; the hook just wires document pointermove, window pointerout, and window blur listeners to tracker methods. The test drops @vitest-environment jsdom, react-dom/client mounting, act, @testing-library/react renderHook, the vi.mock("@/constants/platform") shim, the IS_REACT_ACT_ENVIRONMENT stub, and the getBoundingClientRect patching helper. It calls the tracker directly with fake rect getters and asserts on recorded enter/leave counts. * Make useArchiveSubagent a ports-and-adapters unit test * Make openImagePathsWithDesktopDialog a ports-and-adapters unit test Inject the DesktopDialogBridge into openImagePathsWithDesktopDialog instead of reaching for getDesktopHost() inside the function. useImageAttachmentPicker passes getDesktopHost()?.dialog at the call site; the native sibling matches the new signature. The test drops vi.mock("@/desktop/host", ...) and vi.hoisted() in favor of a typed in-memory fake dialog that records the options it was called with. No global module substitution, no spies — the test reads the fake's recorded state. * Make useIosHardwareKeyboardSubmit a ports-and-adapters unit test * Make UpdateCalloutSource a ports-and-adapters unit test Extract resolveUpdateCalloutDescriptor as a pure function that maps updater state to a structured callout descriptor. UpdateCalloutSource becomes a thin React shim that materializes the descriptor's icon and description as ReactNodes before registering with the sidebar callout API. Replaces a 259-line JSDOM + react-dom/client test that mocked five modules (unistyles theme, lucide icons, async-storage, openExternalUrl, useDesktopAppUpdater) and mounted SidebarCalloutProvider/Slot just to assert deterministic title/description/action/dismissal-key derivations. The new test exercises the resolver directly with zero React, zero DOM, zero mocks. * Delete dead useWorkspaceNavigation hook + collapse re-export indirection The hook had zero production callers — only its own test, which used vi.hoisted + vi.mock + jsdom + @testing-library/react/renderHook to verify a useCallback wrapper. The file also re-exported navigateToWorkspace from the navigation store, so five production importers and two sibling tests reached the store through a hook-module path that had nothing to do with hooks. Retargets every importer to @/stores/navigation-active-workspace-store directly and removes the indirection module + its slop test. * Make useCheckoutStatusQuery a ports-and-adapters unit test Extract peekOrFetchCheckoutStatus and applyCheckoutStatusUpdate to a sibling checkout-status-cache.ts so both pure functions operate on an injected QueryClient and CheckoutStatusClient, with no React or host runtime imports. useCheckoutStatusQuery becomes a thin shell that composes useQuery + useEffect and delegates the cwd-filter + cache write to applyCheckoutStatusUpdate. Replaces a 318-line JSDOM + react-dom/client + fake-timers test that mocked @/runtime/host-runtime via vi.hoisted, mounted a Probe component to read the hook's data, and captured the subscription handler in a hoisted Set. The new test exercises both functions directly against a real QueryClient — zero React, zero DOM, zero mocks, zero fake timers. * Make workspace-navigation a ports-and-adapters unit test * Make navigateToAgent a ports-and-adapters unit test * Make redirectIfArchivingActiveWorkspace a ports-and-adapters unit test * Make openProjectDirectly a ports-and-adapters unit test * Make navigation-active-workspace-store a ports-and-adapters unit test * Make desktop-attachment-store a ports-and-adapters unit test * Make readDesktopSystemIdleTimeMs a ports-and-adapters unit test Rename getDesktopSystemIdleTimeMs to readDesktopSystemIdleTimeMs and take the desktop IPC invoker as a parameter. The single caller in use-client-activity.ts now imports invokeDesktopCommand directly and passes it; the test wires a typed fake invoker. Drops vi.mock("@/desktop/electron/invoke"), vi.hoisted, and the four vi.spyOn(console, "warn") log assertions. Tests now assert the documented behaviour (returns ms, or null) against an in-memory fake. * Make useDesktopAppUpdater a ports-and-adapters unit test Extract the check/install state machine from the React hook into a pure createDesktopAppUpdater runtime that exposes getSnapshot/subscribe/ checkForUpdates/installUpdate. The hook now wires real production deps into the runtime and bridges its snapshot via useSyncExternalStore; React-driven concerns (pending-update interval, initial silent check) stay in the hook. Drops JSDOM, @testing-library/react, renderHook, the three vi.mock calls and the vi.hoisted state shim from the test. The new test wires a typed FakeDesktopAppUpdaterPort recording recordedChecks/recordedInstalls and exposes deferNextCheck/failNextCheck/nextInstallResult so the behaviour assertions read as plain English (status transitions through checking, available, pending, up-to-date, error; race cancellation drops older results; install errors get reported once). * Make sidebar-collapsed-sections-store a ports-and-adapters unit test * Make session-store-hooks a ports-and-adapters unit test * Make panel-store a ports-and-adapters unit test * Make workspace-tabs-store a ports-and-adapters unit test * Make desktop-preview-url a ports-and-adapters unit test * Make client-id a ports-and-adapters unit test * Make browser-store a ports-and-adapters unit test * Make local-file-attachment-store a ports-and-adapters unit test * Make draft-store a ports-and-adapters unit test * Make rich-clipboard a ports-and-adapters unit test * Make desktop-daemon-transport a ports-and-adapters unit test * Make image-attachment-picker.native a ports-and-adapters unit test Extract the pure normalize logic into image-attachment-picker.native.pure.ts and take the PNG exporter as a port. The .native.ts entry wires the real expo-image-manipulator adapter; the test wires a fake exporter and asserts on its recorded uris. Drops vi.mock("expo-image-manipulator") and the inline ImageManipulator stub from the test. Production callers of normalizePickedImageAssets are unchanged. * Make tool-call-icon a ports-and-adapters unit test Split the pure icon-identity decision into tool-call-icon-name.ts and keep the lucide/PaseoLogo component lookup in tool-call-icon.ts. The resolver returns a ToolCallIcon string ("bot", "brain", "paseo", ...); componentForToolCallIcon does the React component mapping; the existing resolveToolCallIcon is the composition. Drops vi.mock("lucide-react-native") from the test and the brittle "expect(icon).toBe(iconMocks.Bot)" pattern — the unit project couldn't evaluate lucide-react-native, which is why the mock existed in the first place. The test now asserts on string identifiers and imports only the pure module. buildToolCallPresentation's resolveIcon port is unchanged; the single caller (components/message.tsx) keeps passing resolveToolCallIcon and gets the same component back. * Make desktop-permissions a ports-and-adapters unit test The test was the heaviest globalThis-juggling test in the app package: vi.doMock("react-native") + vi.resetModules() per case to swap the platform, ensureWindow/setNavigator/restoreGlobals to swap globalThis.Notification, globalThis.navigator, and window.paseoDesktop. That whole setup existed because the production module reached into four ambient sources (Notification, navigator, getDesktopHost(), isWeb/isNative) without a port. Extract a DesktopPermissionEnvironment interface — { isWeb, getDesktopHost, getNotification, getNavigator } — and rebuild the module around a createDesktopPermissions(env) factory. The real environment binds to the actual globals at module load and the existing top-level exports (shouldShowDesktopPermissionSection, getDesktopPermissionSnapshot, requestDesktopPermission) are thin references onto it, so the only caller (use-desktop-permissions.ts) is unchanged. The test now constructs a fakeEnvironment per case and calls into createDesktopPermissions directly — no JSDOM, no vi.doMock, no vi.resetModules, no globalThis writes. The eight behaviors are preserved. * Make provider-icons a ports-and-adapters unit test Split the pure provider→icon-identity decision into provider-icon-name.ts and keep the lucide/SvgXml/catalog component lookup in provider-icons.ts. resolveProviderIconName returns a ProviderIconName ({kind:"builtin"|"catalog"|"bot", id?}), and getProviderIcon composes it with the catalog/builtin component maps. Drops vi.mock("lucide-react-native") from the test — the previous "expect(icon).toBe(iconMocks.Bot)" pattern only existed because the unit project couldn't evaluate lucide-react-native. The new test asserts on discriminated-union identifiers and imports only the pure module. The 13 outside callers of getProviderIcon are unchanged. * Make crypto polyfill a ports-and-adapters unit test * Delete redundant JSDOM Index route test packages/app/src/app/index.test.tsx mounted the Index component through JSDOM + createRoot + @testing-library/react, mocked five modules (expo-router, _layout, desktop-daemon, startup-splash-screen, navigation-active-workspace-store), and asserted that <Redirect> got rendered with the right href across six scenarios. Each of those six scenarios is a one-to-one duplicate of a pure case already covered in host-runtime-bootstrap.test.ts, which tests the same two decision functions (resolveStartupRedirectRoute, resolveStartupWorkspaceSelection) directly. The component is pure wiring: it reads four hooks, calls the two decision functions, and renders the result. There is no logic in Index to verify that the pure tests do not already cover. Drop the JSDOM file; the wiring is covered by app E2E. * Make review-draft-store a ports-and-adapters unit test * Make new-workspace-empty a ports-and-adapters unit test * Extract shared drag-reorder state machine for web sortable lists * Extract pure subagents track presentation helpers Move formatHeaderLabel and resolveRowLabel out of track.tsx into a colocated track-presentation.ts. Six header-copy tests that previously mounted React under JSDOM with eight vi.mocks now run as plain unit tests against the pure helpers. * Make terminal-file-drop a ports-and-adapters unit test * Extract pure import-session-sheet view-model helpers Move resolveProvidersToFetch, buildProviderLabelMap, aggregateSessionEntries, sumFilteredAlreadyImportedCount, collectErroredProviderLabels, getSessionTitle, getPromptPreview, and computeEmptyState out of import-session-sheet.tsx into a colocated import-session-sheet.pure.ts. Add 28 pure unit tests that exercise provider resolution, dedupe/sort, error label fallback, title fallback, and the empty-state state machine directly — no JSDOM, no vi.mock. The existing 859-line JSDOM import-session-sheet.test.tsx stays for now; next ticks can replace its status-message and empty-state cases with the pure coverage. * Make subagents track a ports-and-adapters unit test Move the row-presentation data builder from track.tsx into the colocated pure track-presentation.ts and cover statusBucket, titleState, and label in plain node tests. Delete the 235-line JSDOM track.test.tsx with its eight vi.mocks and createRoot harness — the remaining behaviours (empty returns null, useState toggle, onPress wiring) are React idioms covered by the framework, not domain logic. * Make isolated-bottom-sheet-modal a ports-and-adapters unit test * Stop UI from leaking through subagents barrel The subagents/index.ts barrel re-exported SubagentsTrack (the React component) alongside pure logic like selectSubagentsForParent. Any pure consumer of the barrel transitively pulled in lucide-react-native and react-native-unistyles, forcing tests that only touch pure logic to declare cosmetic vi.mock blocks for icons, theme, tooltip, and provider icons just to get the import graph to load. Drop SubagentsTrack from the barrel. The one external caller (panels/agent-panel.tsx) deep-imports from @/subagents/track instead. The workspace-subagents-integration test loses 56 lines of pretend-UI mocks; only the AsyncStorage mock remains because workspace-layout-store uses it directly through persist middleware. * Collapse use-hover-safe-zone.pure.ts into hover-safe-zone-tracker.ts The `.pure.ts` suffix mimics tooling-resolved variants (`.web.ts`, `.native.ts`, `.test.ts`) without being one. The file exports a single tracker; rename it after its role. Test sits next to its subject by name. * Promote use-settings to a directory module * Promote sidebar-collapsed-sections-store to a directory module * Promote navigate-to-agent to a directory module The `.pure.ts` filename suffix mimics tooling-resolved variants (`.web.ts`, `.native.ts`, `.test.ts`) without being one. Move the pure resolver and its wired wrapper into `utils/navigate-to-agent/`, where the directory carries the domain and `resolve.ts` names the role. The pure function is renamed `resolveNavigateToAgent` so it no longer collides with the wrapper's exported `navigateToAgent`. * Collapse use-client-activity.pure.ts into client-activity-tracker.ts * Collapse open-project.pure.ts into open-project.ts * Promote use-changes-preferences to a directory module Replaces the .pure.ts / .test-utils.ts double-suffix with a directory home that mirrors hooks/use-settings/: hooks/use-changes-preferences/ index.ts ← React hook; wires AsyncStorage storage.ts ← pure load/save storage.test.ts ← tests against storage fakes.ts ← in-memory KeyValueStorage adapter External callers continue importing @/hooks/use-changes-preferences unchanged (resolves to index.ts). * Promote draft-store to a directory module * Collapse use-archive-agent.pure.ts into use-archive-agent.ts * Rename import-session-sheet.pure.ts to import-session-sheet-view-model.ts * Rename image-attachment-picker.native.pure.ts to picked-image-normalizer.ts * Inline use-agent-initialization.pure.ts into use-agent-initialization.ts * Rename use-sidebar-workspaces-list.pure.ts to sidebar-workspaces-view-model.ts * Rename review/store.pure.ts to review/state.ts * Promote browser-store to a directory module * Promote navigation-active-workspace-store to a directory module * Promote panel-store to a directory module * Promote session-store-hooks to a directory module * Promote workspace-tabs-store to a directory module * Rename use-archive-subagent.pure.ts to archive-subagent.ts * Rename sidebar-workspace-archive-redirect.pure.ts to workspace-archive-redirect.ts * Rename workspace-navigation.pure.ts to prepare-workspace-tab.ts	2026-05-28 12:34:31 +08:00