86 Commits

Include renames

Author	SHA1	Message	Date
3 people	667664847d	Connect to remote daemons over SSH (#3989) ... Add transport-only SSH connectivity for the CLI and Electron desktop through the user's OpenSSH configuration. Remote installation and daemon lifecycle remain explicit, separate operations. Preserve actionable SSH failure details when the proxy socket closes before the SSH child exits. Closes #3949 Co-authored-by: James Strain <jstrain@nvidia.com> Co-authored-by: Reid Levesque <reidlevesque@users.noreply.github.com>	2026-08-28 16:32:12 +02:00
Mohamed Boudra	0ad69d3eb0	fix(app): paint conversations immediately after restart (#3907) ... * fix(app): paint cached conversations before reconnect Cold startup restored every saved host before publishing any session, so a valid cached chat was blocked behind unrelated directory validation and network-only readiness. Directory and timeline owners now resolve demand through typed storage and authoritative reconciliation while consumers remain source-agnostic. * fix(app): stabilize demand-driven cache restore Create host projections before network availability, route cached workspace and timeline preparation through their owners, and coalesce directory reconciliation per online connection. Update browser cache fixtures for per-agent timeline rows. * fix(app): resume cached timeline through owner * fix(app): surface timeline owner load errors	2026-08-26 22:55:48 +02:00
Mohamed Boudra	579c6a58f5	feat(app): switch replica cache to row storage ... Persist only changed replica entities so steady-state writes scale with the update rather than the complete cached world. Restore remains an all-or-nothing validated boundary, with whole-host byte-budget eviction.	2026-08-25 23:38:38 +02:00
Mohamed Boudra	e19d3914ae	fix(rewind): replace long timelines without replay (#3642) ... * fix(rewind): refresh canonical timeline after rewind A rewind replaces the daemon timeline and epoch, but replaying the rebuilt history made long conversations visibly reload from the beginning. Capable clients now refresh the existing bounded tail path after a replacement signal while legacy clients retain replay compatibility. * test(rewind): cover coherent timeline replacement Hold rewind completion in the browser regression so it can verify the existing pending state and detect any reconstructed timeline rows before the normal tail refresh is allowed to finish.	2026-08-25 23:37:12 +02:00
Mohamed Boudra	33cf6cf337	perf(app): defer replica persistence until user inactivity ... Whole-replica capture and serialization blocked the JS thread during navigation and streaming. Defer that work until the user has been inactive while allowing long-running streams to persist without becoming the idle signal.	2026-08-22 20:57:13 +02: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
Mohamed Boudra	373a98c64d	Restore host directories instantly before reconnect (#3259) ... * feat(sync): restore host directories before reconnect Persist complete project, workspace, and active-agent replicas so every registered host can paint immediately, including offline hosts. Reconcile those replicas through monotonic per-entity cursors on the existing directory RPCs without retaining an event journal. * fix(sync): preserve active turn identity during catch-up Own Agent-to-wire projection beside the existing snapshot normalizer so replica persistence does not reach through directory-sync internals. This also keeps identified active turns intact when unchanged agents are folded into an incremental directory response. * test(e2e): inspect the real IndexedDB replica Keep cache setup, reload, and hydration coverage on the production browser storage backend after the replica moved off localStorage. Measure writes at the actual IndexedDB put boundary as well. * fix warm reconnect cache paths * feat(sync): persist project icons and deepen directory sync * fix(sync): preserve project update order * fix(cache): preserve validated replica persistence * fix(sync): retain cached agents during catch-up	2026-08-13 23:10:44 +02:00
Mohamed Boudra	36312352db	fix(app): validate persisted client state (#3289) ... * fix(app): validate persisted client state Persisted replica data could satisfy TypeScript through an assertion while missing fields required by renderers. Treat every AsyncStorage value as untrusted input, clear values that fail strict schemas, and version the replica DTO so incompatible caches cannot hydrate. * fix(app): preserve validated legacy state * fix(app): preserve validated preferences Preserve supported legacy location fields and every shipped theme while keeping unknown persisted fields rejected. Align browser test seeds with the current preference shape so strict validation exercises the intended provider. * fix(app): migrate legacy agent preferences Released clients stored host/location fields and per-provider thinkingOptionId together. Migrate those exact strict bytes into current preferences without admitting unknown fields. * fix(app): preserve drafts with legacy reviews Accept the exact strict shape released for workspace review attachments so migration can discard that obsolete attachment without clearing every persisted draft.	2026-08-13 12:02:39 +02:00
Mohamed Boudra	6aa9f92156	Stop notifications after removing a host (#3176) ... * fix(notifications): stop pushes after host removal Push tokens were persisted indefinitely with no relationship to app pairing state. Give registrations a 48-hour renewable lease so offline unpairing converges, and revoke immediately when the host is reachable. * fix(notifications): make token revocation bounded and durable	2026-08-10 23:33:31 +02:00
Mohamed Boudra	fd9cc5d693	Restore macOS direct LAN connections (#3071) ... * fix(desktop): restore direct LAN connections Desktop 0.3.0 routed remote WebSockets through the Electron main process, causing previously working macOS LAN connections to fail with EHOSTUNREACH. Revert custom direct headers and restore the renderer WebSocket path used before the regression. * fix(app): replace host connections by identity Keep one connection per stable ID when TLS or password settings change. This preserves the current-main upsert invariant while the custom-header rollback removes the unrelated transport feature.	2026-08-09 15:32:31 +08:00
Mohamed Boudra	a5184fd08a	fix(app): keep browser relay WebSockets protocol-neutral (#2976) ... Use the standard browser WebSocket constructor without the Node/React Native options object, while retaining the options-capable factory for supported runtimes and the desktop bridge.	2026-08-07 17:30:43 +08:00
Mohamed Boudra	c1f7ed3198	Improve reconnect status feedback (#2931) ... * fix(app): debounce reconnect status toast Keep reconnect transport immediate while delaying the visible status toast so brief outages stay quiet. Scope the toast to the active retained panel, keep its copy and status dot consistent across locales, and add a manual real relay deployment journey that verifies streaming recovery without user action. * fix(app): isolate manual relay deployment check Keep the deployment journey out of the provider-wide real test project so it runs only when its local relay prerequisites are explicitly requested. Also keep the relay teardown active when packaged daemon startup or later cleanup fails. * fix(app): preserve reconnect toast across tabs Keep reconnect presentation timing at the host level so switching between retained panels does not restart the debounce or flash the toast. Add a browser regression covering a visible outage across retained tab switches. * fix(app): anchor reconnect debounce to host status Record host connection status transitions independently of mounted agent panels and preserve the outage start across reconnecting states. Use that host-level timestamp when a visible agent panel appears, with runtime coverage for the transition lifecycle. * fix(app): reset reconnect toast state per outage * test(app): build relay journey prerequisites	2026-08-06 13:45:34 +02:00
3 people	73ba37a07a	Add custom headers to direct connections (#2922) ... * Add custom headers to direct connections * Address custom header review feedback * Fix direct connection header integration * Fix desktop relay E2E transport setup --------- Co-authored-by: Claude <claude@Claudes-Mac-mini.local> Co-authored-by: Mohamed Boudra <boudra.moha@gmail.com>	2026-08-06 11:05:40 +02:00
Mohamed Boudra	48bdc5610f	fix(app): preserve active host connection choices (#2905) ... Settings lost the workspace host when entering the app-wide route, while desktop bootstrap could restore a removed local connection before the saved registry was ready. Use the remembered workspace host for Settings and only register the managed daemon when its server is unknown after registry hydration.	2026-08-05 20:26:41 +02:00
Mohamed Boudra	7dbeff8290	perf(app): reduce startup websocket work ... Make provider catalogs compact and content-addressed so repeat launches can reuse the persisted snapshot instead of transferring it again. Remove eager global catalog loading and the stopped-agent defensive tail fetch, while keeping sequence-gap and reconnect recovery as the correctness paths. Add an opt-in production-ID Android profiling build for local startup traces.	2026-08-04 15:45:55 +02:00
Mohamed Boudra	ccb668b3b4	Improve sidebar workspace readability and host identity (#2790) ... * fix(app): align turn footer actions Keep running-turn actions in the same position as completed-turn actions and use the shared small icon size for both copy and fork controls. * feat(app): improve sidebar workspace identity Make dense sidebar workspace rows easier to scan and let each device control how connected hosts are identified. * fix(app): keep host badges readable Use a compact display menu and keep identity color on the host icon so translated controls fit and badge text retains standard contrast. * fix(app): announce selected sidebar badge mode * fix(app): retain icon-only host names for screen readers * fix(app): name hoisted workspace rows * fix(app): retain host identity in workspace labels * fix(app): retain workspace status in row labels * fix(app): defer host appearance until identity resolves * fix(app): serialize host appearance writes * fix(app): serialize host registry writes * fix(app): bound sidebar host badge labels * test(app): match workspace status labels * fix(app): consolidate sidebar identity behavior * test(app): assert status grouping behavior * fix(app): keep sidebar row actions accessible * fix(app): stabilize optimistic message layout	2026-08-02 16:58:20 +02:00
Mohamed Boudra	5a30affd7f	Skip unrelated required checks without losing their names (#2542) ... * fix(ci): skip unrelated required checks cleanly Matrix jobs had to start no-op runners to preserve interpolated required-check names. Static named jobs let GitHub report genuine skipped conclusions while keeping those names stable. * fix(ci): gate changes to install patching script * fix(ci): route cross-package test contracts narrowly * fix(ci): keep routed contracts merge-blocking * fix(server): exclude nested test utilities from builds * fix(ci): cover app-owned native and browser domains * refactor(ci): align tests with runtime domains Own browser specs, desktop specs, and Electron-only app code by stable directories so PR routing does not depend on filename conventions. Keep desktop integration coverage inside the required desktop check. * fix(ci): keep routing and desktop suites isolated The routing regression must run before dependency installation, and desktop Vitest must not collect Playwright-owned specs. * fix(ci): isolate desktop e2e runtime * perf(test): isolate Playwright workers * perf(test): parallelize Playwright within specs * fix(test): keep Playwright file scheduling * fix(test): share dynamic Metro fixture * fix(test): preserve own-host restart fixtures * fix(ci): preserve routed contracts after rebase * Stabilize Playwright wheel-scroll assertions	2026-08-02 00:56:05 +08:00
Mohamed Boudra	8021d2b6c9	Keep agent timelines stable from submission through resume (#2718) ... * Reapply: Stop completed turns from appearing stuck (#2484) * Reapply: Keep older chat history and image previews stable (#2490) * Lock timeline layout stability with user-driven specs Two reds reproduce the reported jank: - new agent, first prompt: the row paints at top=100 then jumps to 144 through authoritative hydration, because the draft tab and the agent panel each render their own AgentStreamView for the same logical row. - long loaded timeline, submit: scrollHeight collapses 10793 -> 9111 mid-turn, because splitOrderedTail reclassifies measured rows into the virtualized segment where the virtualizer falls back to estimateStreamItemHeight. Also restores centered timeline rows: the pagination anchor wrapper introduced in #2490 was a plain block div, which broke alignSelf: center. * Measure the turn footer blink from when the footer appears Bounding the window at the prompt row conflated two things: the footer arriving a frame after the row, and the footer leaving the layout and coming back. Bounded from the footer's first frame, the blink still reproduces, so the footer-ownership race is real rather than a sampling artifact. * Rename the shadowed prompt row binding in the frame recorder * fix(desktop): allow concurrent worktree dev instances Desktop terminals can inherit another instance's profile path and debugging flags. Scope the profile to the current dev root and select an available debugging port so instances do not share global runtime state. * fix(desktop): expose development providers in dev builds Desktop-managed daemons inherited no Paseo runtime mode, so dev builds constructed the production provider registry. Mark unpackaged internal launches as development while continuing to force packaged launches to production. * fix(timeline): stabilize optimistic turn layout Keep initial history loading dormant until user intent and preserve active-turn layout across delayed transport updates. Add painted-frame coverage for optimistic timeline transitions. * fix(timeline): preserve optimistic prompts through hydration Canonical replacement relied on a transport submission record that can settle before a provider echoes the user row. Keep presentation continuity owned by the unreconciled row while destructive history replacement remains governed by active transactions. * fix(timeline): make submitted prompts canonical Submission settlement previously depended on status updates that could arrive after the optimistic row. Persist every accepted prompt in the canonical timeline and keep the footer active until RPC and canonical acknowledgement converge. * fix(timeline): stop older history pages repeating entries Backward pagination counted source sequence rows, so page boundaries inside a merged projected item could return that item repeatedly. Count projected entries and advance from their display anchors instead, with server and browser regressions covering the contract. * fix(timeline): resume agents from the latest history Use a bounded tail probe on resume so long background runs appear atomically instead of replaying every missed page. Preserve unchanged views, reconcile local/live rows, and keep skipped history reachable through backward pagination. * fix(timeline): reconcile turn state after missed updates Turn completion events can be missed while an agent timeline is unsubscribed, leaving footer activity stale even after the directory reports idle. Reconcile the single-owned turn lifecycle from authoritative resume snapshots while preserving newer live evidence. * test(timeline): cover running state across refresh Protect the hydration boundary where directory state must restore consistent tab, composer, and footer activity. Expose the running indicator semantically so the regression checks user-visible state instead of spinner implementation details. * fix(timeline): keep history loading geometry stable Reserve a fixed history-start gutter regardless of pagination state so showing or hiding the loader cannot shift timeline content. * fix(timeline): keep turn activity coherent Derive footer, tab, and composer activity from one lifecycle and submission projection. Idle directory transitions now request an authoritative resume so missed terminal events converge without treating directory delivery order as turn authority. * fix(tests): align checks with runtime boundaries * fix(desktop): stop dev app surviving its terminal Electron was detached from the desktop runner, allowing it to outlive a stopped workspace terminal with broken output pipes and retain the single-instance lock. Keep Electron owned by the runner and preserve explicit process-group cleanup for detached child trees. * fix(timeline): preserve activity through turn handoff Correlate lifecycle events and snapshots with daemon-owned turn identity, and keep optimistic submissions active until their canonical row arrives. This prevents stale updates and RPC timing from exposing a false idle state. * refactor(timeline): remove submission timing state * fix(timeline): restore prompt identity on resume * fix(timeline): exclude attachments from canonical prompt text Structured provider prompts can include hidden history attachments before the user's text. Persist only plain prompt blocks so authoritative user messages match what the composer displayed while provider input remains unchanged. * refactor(agent): remove unused pending-run message identity * fix(desktop): let Chromium allocate the debugging port * refactor(agent): remove impossible finalized-turn tracking * fix(timeline): load history after keyboard scrolling Treat observed upward displacement as user intent so keyboard and scrollbar navigation can wake dormant pagination. * test(server): preserve accepted turn stream order The manager-owned accepted turn boundary intentionally precedes coalesced output. Assert that lifecycle event explicitly while retaining the timeline-before-terminal ordering contract. * test(app): scope sidebar fixtures by identity Shared E2E daemon state may contain unrelated projects. Keep stale-route coverage tied to its named missing project and drag only the two rows seeded by the reorder spec. * fix(timeline): gate prompt revisions by client capability * fix(timeline): finalize canonical prompt delivery Treat provider identity as a single stored-row transition so legacy clients receive one deliverable canonical prompt. Release identity-pending rows before later foreground output or the current terminal while preserving stale-turn isolation. * fix(server): preserve legacy prompt pagination * fix(timeline): keep assistant block identity stable Assign canonical block IDs during live promotion so terminal finalization cannot remount image-bearing rows. * fix(timeline): apply covered revisions during resume append Run the exact canonical revision pass before overlapping resume pages append newer rows, while leaving cursor advancement to the incremental path. * fix(server): preserve queued agent transitions Project each queued live snapshot before awaiting stored metadata so later lifecycle state cannot overwrite an earlier transition. * fix(server): snapshot queued agent updates Capture each live agent payload before it enters the per-agent queue so shared nested state cannot change while an earlier storage read is pending. * docs(app): date agent turn compatibility cleanup * refactor(timeline): mint submitted prompt identity at acceptance Canonical prompt rows now keep one immutable wire identity while provider identity remains internal for rewind translation. This removes the unreleased same-sequence revision and legacy projection contract. * refactor(app): remove prompt revision reconciliation Submitted prompt rows are immutable on the wire, so resume and live reducers no longer need to apply already-covered same-sequence updates. * test(app): cover submitted prompt rewind roundtrip * docs(timeline): describe immutable submitted prompt identity Provider echoes now enrich daemon-internal identity only; wire rows keep their acceptance-time identity and rewind performs the provider translation. * test(server): validate mock rewind targets Reject unknown provider message IDs so app rewind coverage exercises wire-to-provider identity translation. * fix(server): validate rewind before interrupting * fix(server): omit rewind identity for daemon prompts * test(app): guard rewind eligibility and rejection * fix(server): preserve prompt identity across hydration * refactor(timeline): remove stale revision remnants * Revert "fix(server): preserve prompt identity across hydration" This reverts commit 6adcf7e5b0. * fix(timeline): settle missed submission acknowledgements	2026-08-01 14:13:47 +02:00
Mohamed Boudra	acb8506d1f	Revert the timeline optimistic and pagination rework (#2596) ... * Add npm release track invariant and beta dist-tag procedure * Revert "Keep older chat history and image previews stable (#2490)" The timeline optimistic/pagination rework needs more work than main releases can wait for. Reverted together with #2484; both are reapplied on integration/timeline-optimistic-rework. * Revert "Stop completed turns from appearing stuck (#2484)" See the #2490 revert. #2490 built on this submission-authority change, so the two revert and reapply as a pair.	2026-07-29 13:35:43 +02:00
Mohamed Boudra	fa1198c2be	Stop completed turns from appearing stuck (#2484) ... * fix(app): stop completed turns from appearing stuck Turn activity was inferred from a user-message row flag, so a stale duplicate row could keep the working footer active after the turn ended. Track submission lifecycle separately and route every send path through the shared submission flow. * fix(app): guard pending message identity * test(app): measure submission layout independent of scroll * fix(app): keep submitted messages consistent through reconnects Track each in-flight send until its own RPC establishes acceptance, and keep canonical timeline placement authoritative. Restore legacy cached rewind IDs during cache deserialization. * fix(app): close canonical submission races * test(app): cover canonical submission races in browser * fix(app): keep replacement submissions authoritative Keep current pending rows out of legacy cache migration and leave ambiguous terminal lifecycle events to the daemon snapshot. This prevents fabricated rewind identities and stale completion events from marking replacement turns idle. * fix(app): keep submitted messages stable across sync Give submission transport and canonical timeline ingestion separate authority. Preserve every unresolved local send across replacement, reconcile provider identity once, and bridge RPC acceptance to authoritative running state without deriving lifecycle from timeline rows. * fix(app): settle submissions in either acknowledgement order Complete submission transactions when RPC and provider acknowledgement arrive in either order. Cache only transaction-owned local rows as transient data, preserve canonical ID-less prompts, and invalidate ambiguous legacy display caches instead of inventing provider identity. * fix(app): keep agent visible during history handoff Running and terminal updates could clear create continuity before the initial authoritative timeline arrived, leaving a streaming agent behind the loading screen. End the handoff only when authoritative history is applied. * fix(app): settle attachment-only submissions Canonical providers can acknowledge image-only prompts with empty text. Reconcile those events by client identity without rendering a blank canonical row. * fix(agent): settle out-of-band message submissions Accepted commands that do not allocate a foreground turn previously had no canonical user acknowledgement. Record the command before its handler runs so submission state and reconnect history converge through the normal timeline producer. * fix(app): settle out-of-band submissions compatibly * fix(app): preserve canonical prompt order * test(app): keep workspace status check timing-independent The workspace-status scenario asserted footer settlement before initial agent creation had necessarily completed. The dedicated draft-handoff coverage owns that lifecycle contract.	2026-07-27 21:27:10 +02:00
Mohamed Boudra	d0456b1943	fix(sync): preserve host replicas across provider remounts ... Make the host runtime own session and setup replicas for the registered host lifetime. Provider remounts can then reattach without clearing directory snapshots or timeline cursors.	2026-07-21 13:44:23 +02:00
Mohamed Boudra	07d988488e	fix(sync): show complete workspace and agent history (#2263) ... Cached focused state was leaking into the sidebar before authoritative workspace hydration, while catch-up limits counted raw events instead of projected entries. Keep the focused cache fast, gate directory presentation on hydration, and preserve canonical cursors while paging projected history.	2026-07-20 23:24:45 +08:00
Mohamed Boudra	5ea311f243	feat(app): restore recent chat while reconnecting (#2206) ... Keep a small non-authoritative view of the last focused chat so the app can paint it before the daemon finishes revalidation. Bound persistence to one focused agent per host and evict whole host entries to limit storage and serialization work.	2026-07-19 03:08:46 +08:00
Mohamed Boudra	1977d330ed	Reduce workspace, agent, and chat sync traffic (#2028) ... * feat(sync): keep live data scoped and current Only viewed chats receive live timeline rows, while directory state now uses one subscribed bootstrap followed by ordered deltas. Legacy clients and daemons retain their existing behavior through centralized compatibility gates. * fix(sync): preserve selective delivery boundaries Keep selective timeline capability app-owned, union viewed sets across shared sockets, and reconcile directory side effects from accepted state. Visibility and archive suppression now follow their existing authoritative boundaries. * test(app): align browser fixtures with runtime contracts * fix(sync): preserve mixed-client delivery guarantees * fix(sync): finish paged history before advancing * fix(sync): replay live deltas after refresh failures * test(server): model socket capability lookup * test(app): use platform shortcut for split-pane coverage * fix(app): keep hidden timelines dormant * test(app): normalize split-pane shortcut setup * fix(app): preserve sync state across retries * fix(app): preserve background sync state across races * fix directory bootstrap reconciliation edge cases * fix selective timeline compatibility races * fix superseded directory sync races * fix(sync): centralize directory replica ordering Own agent and workspace refresh transactions in HostRuntime so reconnect epochs, buffered updates, and lifecycle invalidation share one ordering boundary. Route timeline metadata and mixed-capability stream delivery through their authoritative runtime sources. * fix(app): keep timeline requests runtime-scoped * fix(app): close directory bootstrap races	2026-07-17 17:03:34 +02:00
Mohamed Boudra	d9b65e269f	Scheduled runs each get their own workspace in the sidebar (#1934) ... * feat(schedules): per-run workspaces, isolation and archive controls Scheduled agents never appeared in the sidebar: each schedule reused one stamped workspace and archived the run's agent on completion. Now every run mints its own workspace — the entity the sidebar shows — with per-schedule controls for isolation (local or worktree) and whether to archive that workspace when the run finishes. The schedule form is rebuilt on a non-React form model (open/commands/close) to end the flicker, edit-into-create contamination, and multi-host hydration bugs that came from effect-choreographed shared state. That lands the reusable foundations it needed: a form kit over a single control-geometry owner, a data-access taxonomy (replica/snapshot/fetch) with real load-state semantics, and lint/boundary guardrails so new screens inherit the paved road. Also fixes desktop combobox popovers truncating options when the trigger is narrower than the content. New schedule protocol fields are optional on both create and update, so old and new clients/daemons stay compatible. * test(app): complete mock themes for control-geometry tokens switch and terminal-profile-edit-modal now style through createControlGeometry, which reads theme.borderWidth[1], theme.opacity[50], and theme.colors.borderAccent. The hand-rolled mock themes in these two suites lacked those tokens, so the eager StyleSheet.create mock threw at import (collection error), not on any assertion. Add the missing tokens. * fix(schedules): address review findings on run cleanup, edit isolation, load error, sheet dismiss, and preference hydration - Server: archive the run's workspace even when agent creation fails, so a misconfigured provider no longer orphans a sidebar workspace/worktree. - Edit form: keep a stored worktree isolation while worktree eligibility is still resolving, instead of silently downgrading a saved schedule to local. - Schedules screen: show the load error/retry UI when every host fails, rather than spinning forever behind the loading branch. - Form sheet: fire the parent onClose on native gesture/backdrop dismiss so the sheet closes instead of re-opening. - Form model: apply late-loading saved preferences to untouched create-mode fields (never to edited schedules or user-modified fields). * fix(schedules): review batch — reconnect resubscribe, worktree prune, Android dismiss, cadence and provider edit safety - Push-router: re-send terminal and checkout-diff subscriptions after a reconnect; the old per-hook effect resubscribed on isConnected and the extracted router did not, so daemon restarts silently stopped terminals_changed pushes (root cause of the terminal-activity e2e failures). - Server: pass the run's source repo root when archiving worktree runs so the worktree is unregistered (git worktree remove/prune), not just deleted; also archive the workspace when agent creation fails even with archive-off (an agentless workspace has nothing to inspect). - Sheet: RN Modal onDismiss is iOS-only — notify dismiss once-per-close on the Android native path too; replace the JSDOM component test with a real Playwright dismiss spec and inline the trivial dismiss decision. - Form model: editing an interval schedule no longer rewrites its cadence to cron unless the cadence UI is touched (90-minute intervals have no cron equivalent); switching projects clears stale provider/model state and gates submit until the new host's snapshot resolves. * chore(lint): drop custom lint wrapper and boundary script, plain oxlint The import bans stay in .oxlintrc.json (oxlint-native no-restricted-imports). The receiver-sensitive checks the custom script enforced are not worth a parallel lint pipeline; if they come back it will be as oxlint rules. * fix(schedules): crash-safe run cleanup, capability-gated run options, resilient mutations - Persist the run's workspace/agent ids on the running-run record so a daemon crash mid-run can be recovered: restart archives the interrupted run's workspace under the same policy as normal cleanup (agentless always archives, otherwise archiveOnFinish is respected). - Hide Archive on finish (and omit archiveOnFinish/isolation from payloads) on hosts without workspaceMultiplicity — an old daemon ignores the fields, so offering the switch there would lie. - Optimistic pause/resume/delete no longer throw when the schedules cache holds a still-connecting entry alongside loaded data. - Mode field is gated on provider mode options, not a selected model, so model-less providers can pick their advertised modes.	2026-07-07 22:13:42 +02:00
Mohamed Boudra	b28f291493	Generalize browser automation hosting beyond the desktop app (#1878) ... * feat(browser): generalize browser automation hosts Rename the browser automation client capability to a host-neutral payload, advertise supported commands, and route tab-scoped commands by browserId affinity so future browser hosts can register without another protocol shape change. * fix(browser): harden browser host registration Reject unusable browser host capabilities, clean up pending requests when a host registration is replaced, and defer list_tabs affinity updates until every host in the aggregation succeeds. * fix(browser): preserve host tab affinity across reconnects Keep stranded tab ownership tied to the disconnected host so the same host can reclaim open tabs after reconnect, and tolerate future command names in browser_host capability payloads while retaining only known commands.	2026-07-04 01:46:04 +08:00
Mohamed Boudra	20385bdb50	Add opt-in browser tools for desktop tabs ... * Add opt-in browser tools for desktop tabs Adds the daemon opt-in, desktop tab routing, MCP tools, and real browser automation surfaces for Paseo desktop browser tabs. * Fix browser tools CI expectations * Address browser tools review findings * Restrict browser file automation paths * Fix browser upload test on Windows * Harden browser navigation inputs * Make browser tools create usable tabs * Update browser MCP empty-state test * Fail browser tab creation when registration times out * Fix browser screenshots for agents * Hide disabled browser tools from agents * Address browser tools architecture review * Replace browser tools review tests * Wrap browser tab registration errors * Mock Expo Router in app unit tests * Handle invalid browser automation requests * Return browser failure on desktop disconnect * Update browser disconnect websocket test * Relax browser timeout polling test * Handle invalid browser responses * Return browser failure when send fails * Remove local diagnostics and fixture paths * Fix dev service home fallback * Use worktree home for dev services * Use managed daemon in desktop dev * fix(browser): keep agent tabs addressable Track agent-active browser targets separately from human-focused tabs and keep resident webviews alive for automation. Browser tool visibility now comes from registration while the broker reports disabled execution. * refactor(browser): register tools through catalog Move browser tool registration onto the shared Paseo tool catalog so the MCP server remains only the transport adapter. * fix(settings): translate browser tools host error	2026-06-30 22:33:18 +02:00
Mohamed Boudra	f94ec0e430	Keep New Workspace on the current project (#1806) ... * fix(app): keep New Workspace on the active project New Workspace preselection was falling back to stale remembered host state when multiple hosts existed. Pass durable active-project context from workspace entry points and centralize initial host selection so stale offline hosts cannot steal the form while startup restore remains last-workspace only. * fix(app): address New Workspace review feedback * fix(app): stabilize New Workspace host selection * fix(app): preserve New Workspace host fallback * test(app): loosen stale-host project assertion * fix(app): prefer reachable new workspace hosts * fix(app): avoid stale offline workspace preselect * fix(app): prefer online project hosts	2026-06-29 20:44:18 +02: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	4e2c06ec71	Serve the web client from the daemon (#1635) ... * Serve the web client from the daemon Keep the bundled browser UI opt-in and exclude it from desktop packaging so desktop builds do not ship a duplicate renderer. * Escape daemon web UI bootstrap hint * Fix bundled web UI dist path	2026-06-26 12:00:11 +08:00
Mohamed Boudra	3d5059ab05	Keep legacy daemon agents attached to workspaces ... Old daemons can report agents by cwd without workspace IDs. Build path-backed workspace rows for that compatibility path and reapply ownership to legacy snapshots so tab reconciliation keeps those agents visible.	2026-06-18 22:41:48 +07:00
Mohamed Boudra	ea2f768d3f	Keep connections alive through brief daemon slowdowns (#1581) ... * Keep connections alive through brief daemon slowdowns The active connection's liveness check was a side effect of the candidate-probe loop: a single 5s latency measurement doubled as the death timeout, so a daemon that was alive but briefly stalled (e.g. a busy event loop) was misread as dead and the connection was torn down. Give DaemonClient its own self-scheduling heartbeat that solely owns liveness (15s timeout, 2 consecutive misses), and make the probe read-only on the active connection — it reads the heartbeat's last RTT instead of pinging. Split the shared ping into a pure measurement path (measureLatency) and a private liveness path, so nothing outside the client can drive teardown. * Don't let a candidate latency timeout count as a liveness failure The heartbeat (livenessPing) and candidate ranking (measureLatency) share one in-flight ping slot. If a heartbeat tick lands while a candidate measurement is still in flight, the heartbeat dedupes onto it — and a measurement timeout was then recorded as a liveness failure, nudging the connection one step closer to a spurious teardown. Tag each ping with whether its timeout may drive a liveness failure (only the heartbeat sets it) and gate recordLivenessFailure on that flag, so an adopted measurement probe can never contribute to teardown.	2026-06-18 21:10:08 +08:00
Mohamed Boudra	b0ca08a452	Keep git review state fresh after reconnect (#1491)	2026-06-12 16:55:18 +00:00
Mohamed Boudra	d802534e7b	fix(app): preserve workspace route during desktop refresh	2026-06-11 16:08:50 +07:00
Mohamed Boudra	53c14d9855	Extract client SDK package (#1052) ... * Extract client SDK package * Polish SDK client identity defaults * Build client before dependent CI jobs * Restore daemon client server export * Extract protocol and client SDK packages * Fix provider override schema validation * Fix app test daemon client imports * Simplify workspace build targets * Fix CLI test server build bootstrap * Run SDK package tests in CI * Fix rebase package split drift * Restore lockfile registry metadata * Update SDK config test for prompt default * Move terminal stream router test to client package * Fix rebase drift for protocol imports * Fix SDK agent capability fixture * Restore legacy server client exports * Fix server export compatibility test * Advertise custom mode icon client capability * Remove server daemon-client exports * Format rebased mode control import * Fix rebase drift for protocol imports Files added by upstream PRs (#893, #1147, #1154) referenced the pre-split shared/ paths that this branch moves into @getpaseo/protocol. Redirect those imports to the protocol package so typecheck stays green after the rebase.	2026-05-28 01:58:18 +08:00
Mohamed Boudra	dee8f485de	Recover stale daemon connections with liveness probes (#1124) ... Use top-level WebSocket ping/pong for client liveness so session RPC timeouts stay scoped to the operation that timed out. Back off inactive connection probes while a host already has a healthy active connection.	2026-05-21 11:43:22 +08:00
Mohamed Boudra	d24087c10a	Fix relay E2EE reconnect races (#973) ... * Fix relay E2EE reconnect races * fix(relay): use WebSocket protocol ping for daemon control keepalive The daemon's control socket pinged the relay every 10s with a JSON `{type:"ping"}` message. Every JSON message wakes a hibernated Cloudflare Durable Object via `webSocketMessage`, so an idle daemon was billing relay DO CPU 24/7 just to echo `pong`. Switch to `socket.ping()` (RFC 6455 protocol ping frames). Cloudflare's runtime auto-responds at the edge without waking hibernated DOs, so an idle daemon-to-relay connection now costs zero DO CPU. Liveness still works: the `ws` library emits a `pong` event on the daemon when the edge replies, which refreshes `controlLastSeenAt`. `markControlReady` stays tied to DO-originated messages (sync, connected, disconnected), so we still detect a broken DO at connect. The DO keeps its JSON ping handler tagged `COMPAT(relay-json-ping)` so old daemons (< v0.1.76) continue to work. * test(relay): assert protocol-ping pongs arrive in e2e idle test Adds a `relay_control_pong_received` debug log to the daemon's pong handler, then asserts in the existing idle-relay e2e test that: - at least one pong arrived during the 12s idle wait (proving the Cloudflare edge auto-responds to RFC 6455 protocol pings) - no stale terminations fired (proving the keepalive path is healthy) If the daemon ever regresses to JSON-level keepalive pings (which wake the hibernated relay Durable Object and incur CPU billing), this test will catch it: the `pong` event would never fire because the DO's reply would arrive via `message`, not as a protocol pong frame. The test's capturing logger is bumped to `debug` level so the assertion can read the new debug log; production daemons stay at `info`. Confirmed locally against wrangler-hosted relay: 2 pongs / 0 stale per 12s window. * test(relay): catch dual-ping regression via DO-side legacy ping log The existing idle-test assertion catches "revert to JSON ping only" via the missing pong event, but misses the dual-ping regression where someone adds `socket.send(JSON.stringify({type:"ping"}))` alongside `socket.ping()`. Both paths would work, the pong assertion still passes, and DO CPU billing silently returns. Add a console.log in the DO's handleControlKeepalive (which only runs when a JSON ping reaches the DO), then assert in the idle e2e test that no such log appeared during the 12s idle window. Verified the assertion catches the regression: temporarily injected a `socket.send(JSON.stringify({type:"ping"}))` next to socket.ping(), test failed with `expected 1 to be 0` and the relay logged `legacy_json_ping_received`. Removed the injection. Log noise during the COMPAT window doubles as useful telemetry: it counts how many old daemons are still pinging, which informs the removal date for the COMPAT shim.	2026-05-13 13:44:11 +08:00
Mohamed Boudra	cab42985a5	Fix old relay pairing URL TLS compat (#896)	2026-05-10 19:29:56 +08:00
Mohamed Boudra	7558bd7947	Fix dev override host bootstrap (#789)	2026-05-07 13:08:10 +08:00
Mohamed Boudra	2e45650f22	Allow self-hosted relays to opt into wss:// (#767) ... * Add relay TLS schema fields * Wire relay TLS into websocket URLs * Propagate relay TLS from pairing offers * Expose relay TLS opt-in * Mark relay TLS fallback for removal * Preserve explicit relay TLS false * Align relay TLS defaults outside config loader	2026-05-06 17:25:16 +08:00
Mohamed Boudra	fc31d31493	Disable dev client runtime metrics logging	2026-05-03 19:11:25 +07:00
Mohamed Boudraandgithub-actions[bot]	088a6c14c0	feat: direct TCP URI with SSL toggle and optional password auth (#635) ... * feat: direct TCP URI with SSL toggle and optional password auth Replaces the heuristic-driven direct-connection model with a user-controlled one. The Add Host dialog now exposes structured Host, Port, "Use SSL", and masked Password fields that compose the canonical `tcp://host:port?ssl=true&password=xxx` URI used as the storage form. The daemon gains optional shared-secret auth: `Authorization: Bearer <pw>` on HTTP and `Sec-WebSocket-Protocol: paseo.bearer.<pw>` on the WS upgrade (browser WebSocket can't set custom headers). Configured via config.json `auth.password` or `PASEO_PASSWORD` env. Off by default — old clients keep working unchanged. The `port === 443` heuristic for ws/wss is gone; the explicit `useTls` flag drives scheme selection at every call site. * fix: stabilize direct tcp auth ci checks * fix: restore fetch stub in bootstrap smoke test * fix(app): collapse Advanced section in add-host modal * feat(server): hash daemon password in config * fix: update lockfile signatures and Nix hash * Improve direct TCP auth failures * Fix workspace cwd updates after rebase --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>	2026-04-30 22:05:49 +08:00
Mohamed Boudra	5bb177d33b	fix(app): split local-daemon bootstrap into default vs configured override ... EXPO_PUBLIC_LOCAL_DAEMON is a developer directive that the app must show the configured host even when disconnected, so the user can see and diagnose connection failures. The previous bootstrap conflated this with the default "auto-add localhost:6767 if a daemon answers" behavior, and the silent inner catch hid every failure mode. - Split bootstrapLocalhost into bootstrapDefaultLocalhost (probe-then- upsert, unchanged) and bootstrapConfiguredOverride (unconditional upsert with placeholder serverId local:<endpoint>). - Reconcile the placeholder to the daemon's real serverId in place when the probe receives server-info; rekey controllers and listeners. - Replace the silent catch with console.warn carrying endpoint and error. - On every override boot, purge any host owning the override connection under a non-matching serverId so a fresh dev daemon (rotated keypair) no longer leaves the registry pointing at a defunct host. - Prune cross-endpoint placeholders when EXPO_PUBLIC_LOCAL_DAEMON changes. Refs #637.	2026-04-30 18:12:03 +07:00
Mohamed Boudra	40ce317ac2	Reshape desktop bootstrap into independent services ... HostRuntime self-boots via boot() and emits state through existing subscribeAll plumbing. DaemonStartService runs in parallel: on success it upserts the connection, which HostRuntime's syncHosts already wires into a controller; on failure it emits an error. The bootstrap no longer awaits daemon-start before letting saved-host controllers connect. index.tsx resolves the redirect from useEarliestOnlineHostServerId + useDaemonStartLastError subscriptions, not from a procedural promise. The splash error is derived state: splashError = !anyOnlineHostServerId ? daemonStartError : null. Retry calls only DaemonStartService.start(). Deletes initializeHostRuntime, setupDesktopManagedConnection, addConnectionFromListenAndWaitForOnline, bootstrapDesktop on the store, waitForAnyConnectionOnline (now unused in production), and the phase enum. Net -623 lines.	2026-04-27 16:36:07 +07:00
Mohamed Boudra	a2c68cc689	feat: restore last workspace on cold start ... Persist the user's last active workspace and navigate directly to it on cold start instead of always landing on the open-project screen. - Unified bootstrap into one cross-platform wait step after platform-specific connection setup - Store-level wait with workspace preference: preferred host online resolves immediately, grace period if a different host connects first, bounded 5s timeout for unreachable hosts - index.tsx is fully declarative — reads resolved target from context, no useEffect/promises/refs/timers	2026-04-26 11:28:46 +07:00
Mohamed Boudra	1ec448d2b9	fix: prevent bootstrap phase regression when an existing host comes online first ... When a saved host reconnects before bootstrapDesktop finishes, the phase was regressed from "online" back to "connecting". Track the race settlement and skip the setPhase("connecting") call if anyOnline already won. Also extract getEarliestOnlineHostServerId into HostRuntimeStore and use it to initialize the bootstrap phase, avoiding a flash of the starting screen.	2026-04-26 08:15:06 +07:00
Mohamed Boudraandgithub-actions[bot]	446dd9cfe6	chore: drive linter to zero, promote warn -> error in CI (#545) ... * chore(lint): use Set for LOG_FORMATS membership check * chore(lint): convert type aliases to interfaces (autofix) - Remove no-use-before-define rule (conflicts with unistyles ordering) - Add typescript/consistent-type-definitions: interface - Run oxlint --fix: 606 type->interface conversions across 268 files Typecheck green. Warnings: 5432 -> 3787 (-1645). * chore(lint): clean up relay package warnings * chore(lint): clean up cli package warnings * chore(lint): flatten nested ternaries in server (no-nested-ternary) * chore(lint): escape entities and hoist inline objects in website * chore(lint): hoist inline arrays in app (jsx-no-new-array-as-prop) * fix(types): restore Record assignability after type->interface autofix * chore(lint): hoist inline arrays in app (jsx-no-new-array-as-prop) * chore(lint): clean up desktop and highlight packages * chore(lint): hoist inline arrays in app (jsx-no-new-array-as-prop) * chore(lint): hoist inline arrays in app (jsx-no-new-array-as-prop) * chore(lint): format keyboard-shortcuts-section * chore(lint): rename shadowed bindings in server (no-shadow) Rename inner bindings that shadow outer imports or function params: - Promise executor `resolve` -> `resolvePromise` (shadowed path `resolve`) - Method params `options` -> `input`/`target`/`update`/`runOptions`/`opts`/`killOptions` - Misc loop/destructure renames for `workspaceId`, `scriptNames`, `path`, `query`, `taskNotificationItem` Mechanical change only; no behavior change. * fix(types): add index signatures for Record assignability * chore(lint): extract nested callbacks in server (max-nested-callbacks) * chore(lint): hoist inline callbacks in app (jsx-no-new-function-as-prop) Work in progress: 30 of 369 warnings fixed across 23 files. * chore(lint): hoist inline callbacks in app (jsx-no-new-function-as-prop) * chore(lint): reduce cyclomatic complexity in server * chore(lint): hoist inline callbacks in app components (jsx-no-new-function-as-prop) * chore(lint): parallelize safe await-in-loop in server * chore(lint): hoist inline callbacks in app (jsx-no-new-function-as-prop) Finish eliminating jsx-no-new-function-as-prop warnings in agent-status-bar.tsx and complete refactor of git-diff-pane.tsx by extracting per-item components and using stable useCallback handlers. * chore(lint): parallelize more safe await-in-loop in server * fix(server): restore microtask ordering in message dispatch and stream event handler The complexity refactor added async dispatcher chains that inserted extra microtasks before message handlers ran, and wrapped the stream event switch in an await that fired between emitState and dispatchStream. Two tests regressed on both counts. Route to the matching dispatcher synchronously and skip the await when the stream handler has no async work. * chore(lint): hoist/memoize inline arrays and objects in app JSX * chore(lint): parallelize safe awaits in server (no-await-in-loop) Converts three sequential `for ... await` loops to `Promise.all`: - OpenCode: configure MCP servers in parallel - Sherpa: download model files and ensure multiple models concurrently - Speech runtime: check required model files across models in parallel * chore(lint): clear website warnings to zero Resolves all 61 oxlint warnings in packages/website/ by hoisting inline callbacks/JSX, extracting sub-components to satisfy jsx-max-depth, using stable data-derived keys, adding explicit button types, flattening nested ternaries, and removing unused code. * chore(lint): parallelize more safe awaits in server (no-await-in-loop) - Workspace reconciliation: archive missing workspaces and orphaned projects concurrently instead of sequentially. - Directory suggestions: resolve child directory candidates in parallel before filtering. * chore(lint): allow css imports in import/no-unassigned-import, hoist host page styles * chore(lint): hoist dictation-controls inline arrays * fix(server): restore microtask ordering in session message dispatch Converts per-group dispatchers to Promise<void> | undefined. The complexity refactor broke two tests by inserting extra microtasks between each dispatcher's await. The new pattern routes synchronously via a nullish- coalescing chain and awaits only the matching dispatcher's promise. * chore(lint): flatten nested ternaries in button/volume-meter/autocomplete * chore(lint): narrow explicit any in misc server files * chore(lint): flatten nested ternaries in host-runtime/host-page/providers * chore(lint): clear desktop warnings to zero Convert polling loops to recursive helpers to avoid no-await-in-loop, and switch the ws import to the named export so the WebSocket type is referenced directly. * chore(lint): remove useless constructors in server tests * chore(lint): hoist pair-scan inline arrays and objects Extracts corner style arrays and barcode scanner settings to module scope, memoizes insets-dependent body/helper text styles. * chore(lint): hoist inline style arrays in question-form-card * chore(lint): hoist/memoize inline styles in plan-card Extracts markdown rule style arrays into dedicated MarkdownInlineText, MarkdownListItemContent, and MarkdownParagraph subcomponents that memoize their own style arrays. Memoizes PlanCard container/title/ description styles. * chore(lint): narrow explicit any in server relay/loader/logger-likes * chore(lint): hoist SheetBackground combined style * chore(lint): hoist inline styles in screen-header * chore(lint): hoist inline styles/objects in menu-header * chore(lint): hoist top-level inline arrays in diff-viewer * chore(lint): narrow explicit any in codex-app-server-agent thread items * chore(lint): reduce max-depth in claude-sdk-behavior test * chore(lint): memoize inline styles in command-center * chore(lint): extract helper to reduce max-depth in agent-response-loop * chore(lint): flatten nested conditions in pi-direct-agent history * chore(lint): reduce max-depth in claude-agent query pump * chore(lint): clear cli warnings to zero Refactor polling loops into recursive helpers to satisfy no-await-in-loop, fix WebSocket named import, and correct an absolute-path import in tests/tmp. * chore(lint): memoize inline styles in context-menu * chore(lint): narrow explicit any in claude-agent/openai stt * chore(lint): reduce max-depth in opencode-agent foreground loop * chore(lint): memoize inline styles in explorer-sidebar * chore(lint): memoize mobile sidebar styles in explorer-sidebar * chore(lint): memoize inline styles in agent-list * chore(lint): reduce relay test no-await-in-loop warnings Refactor while-loops and for-retry loops in e2e.test.ts and live-relay.e2e.test.ts into recursive poll/attempt helpers. Remaining 8 warnings in encrypted-channel.ts concern the custom Transport interface (on-handler slots, not DOM EventTarget) and a sequential send loop; both reflect deliberate runtime contracts. * chore(lint): fix typecheck errors from hoisting refactors - pair-scan: type BARCODE_SCANNER_SETTINGS as BarcodeSettings - explorer-sidebar: add missing desktopSidebarStyle useMemo - sidebar-workspace-list: coerce null dotColor to transparent - menu-header, e2e.test: formatting * chore(lint): memoize inline styles in workspace-screen * chore(lint): memoize inline styles in workspace-desktop-tabs-row * chore(lint): hoist constant style arrays in desktop-updates-section * chore(lint): memoize inline styles in combobox * chore(lint): extract SplitGroupChild to memoize inline styles * chore(lint): memoize inline styles in dropdown-menu * chore(lint): memoize inline styles in workspace-hover-card * chore(lint): memoize inline styles in autocomplete, message-input, composer * chore(lint): remove explicit any in server (129 warnings) - session.ts: catch(error: any) -> catch(error) with Error coercion at use - daemon-client transport: any -> unknown in listener types - sherpa/onnx loaders: introduce structural native types - pocket-tts-onnx: typed ONNX session inputs/outputs/tensors - tests: any -> unknown + named stub types * chore(lint): hoist inline arrays and objects in app (145 warnings) - Hoist static style arrays/objects to module-level consts - Memoize dynamic ones with useMemo and correct deps - jsx-no-new-array-as-prop: 145 -> 43 - jsx-no-new-object-as-prop: 64 -> 21 * chore(lint): memoize inline styles in _layout Fixes 3 react-perf/jsx-no-new-object-as-prop warnings in root layout by memoizing the stack screen options, the agent screen override, and the GestureHandlerRootView root style. * chore(lint): memoize inline styles and objects in stream/status panes Clears 10 react-perf/jsx-no-new warnings across welcome-screen, file-explorer-pane, terminal-pane, agent-stream-view, and agent-status-bar by extracting per-item subcomponents, hoisting constant style tuples, and memoizing derived arrays/objects. * chore(lint): memoize inline style objects in list/pane components Clears 6 react-perf/jsx-no-new-object-as-prop warnings across synced-loader, stream-strategy-web, sortable-inline-list, file-pane, and both draggable-list platform variants by memoizing or hoisting their inline style objects. * chore(lint): hoist test fixture arrays/objects Clears 14 react-perf/jsx-no-new-* warnings across app test files by hoisting constant fixtures to module scope or wrapping them in helper factories so they no longer appear as inline JSX prop values. * chore(lint): memoize inline styles in message components Clears 5 react-perf/jsx-no-new-* warnings in message.tsx by memoizing image source objects, extracting an AssistantMessageBlockContainer for per-block spacing, and moving todo list item rendering into a TodoListItemRow subcomponent so each row memoizes its own style arrays. The remaining 8 warnings in react-native-markdown-display render rules are inherent to that library's rule API. * chore(lint): remove unused vitest imports in server tests * chore(lint): remove unused helpers and vars in server tests * chore(lint): add explicit returns in then() callbacks in server * chore(lint): fix no-shadow and no-nested-ternary in server * chore(lint): flatten nested blocks to satisfy max-depth in server * chore(lint): extract helpers to satisfy max-depth in server * chore(lint): parallelize Claude persisted agents lookup Replace sequential parseClaudeSessionDescriptor loop with Promise.all to fix no-await-in-loop warning. * chore(lint): parallelize Linux watch directory traversal Switch BFS to level-by-level Promise.all over readdir calls, replacing the sequential pop/await loop that triggered no-await-in-loop. * chore(lint): parallelize workspace registry bootstrap upserts Collect per-workspace upsert inputs in a sync pass, then run registry writes via Promise.all to eliminate no-await-in-loop warnings. * chore(lint): parallelize test daemon cleanup rm calls Run the paseoHomeRoot/staticDir removals concurrently in close() and the startup catch block to fix no-await-in-loop. * chore(lint): mechanical cleanup in app (unused, shadow, nested-ternary) Recovers in-flight edits from the app mechanical agent that couldn't be pushed due to concurrent tree contention. Removes unused helpers and locals, flattens nested ternaries, narrows a few props where unused. * chore(lint): parallelize pending permission approvals approvePendingPermissions now filters and records handled IDs in a sync pass, then awaits all allowPermission calls concurrently instead of looping awaits. * chore(lint): parallelize rebase head-name lookup Try both rebase backends (rebase-merge, rebase-apply) concurrently via Promise.all and return the first non-null result. * chore(lint): no-unused-vars in app * chore(lint): parallelize worktree terminal bootstrap Start each bootstrap terminal concurrently via Promise.all. Since every spec creates an independent terminal and returns a standalone result, parallelization preserves order while removing two no-await-in-loop warnings. * chore(lint): parallelize worktree bootstrap test cleanup and script spawn Run terminal cleanup across managers and spawnWorkspaceScript for api and web concurrently to eliminate no-await-in-loop warnings while preserving semantics. * chore(lint): prefer-add-event-listener in app * chore(lint): parallelize script-health-monitor afterEach and spawns Close all stub TCP servers concurrently and spawn typecheck/api scripts via Promise.all to drop two no-await-in-loop warnings. * chore(lint): jsx-no-useless-fragment in app * chore(lint): parallelize executable PATH probing * chore(lint): parallelize client and relay transport test cleanup * chore(lint): parallelize agent storage record file probing * chore(lint): no-array-index-key in app * chore(lint): parallelize bootstrap provider availability cleanup * chore(lint): parallelize Codex rollout file search * chore(lint): parallelize dictation wav fixture search * chore(lint): parallelize Claude session id fixture test * chore(lint): parallelize script health monitor server cleanup * chore(lint): parallelize Codex skills directory scan * chore(lint): promise/always-return in app * chore(lint): no-shadow in use-dictation, hoist icons in splash screen * chore(lint): no-shadow in composer callbacks * chore(format): apply oxfmt to 3 server files * chore(lint): no-explicit-any in stt-manager/chat-mentions tests * chore(lint): no-shadow in small app files Rename inner shadowing identifiers in: - add-host-modal, agent-status-bar, sidebar-workspace-list, terminal-pane - workspace-setup-dialog, session-context, use-is-local-daemon - setup-panel, new-workspace-screen, workspace-desktop-tabs-row * chore(lint): no-explicit-any in claude-agent.test * chore(lint): no-shadow in small app test/e2e files * chore(lint): no-explicit-any in workspace-git-service.test * chore(lint): no-shadow in app test hoisted blocks * chore(lint): no-explicit-any in websocket-server.runtime-metrics.test * chore(lint): no-explicit-any in acp-agent.test * chore(lint): no-shadow in app composer/message-input/e2e helpers * chore(lint): no-explicit-any in session.workspace-git-watch.test * chore(lint): no-explicit-any in websocket-server.notifications.test * chore(lint): no-shadow in sidebar-workspace-list.test, use-pr-pane-data.test * chore(lint): no-explicit-any in websocket-server.relay-reconnect.test * chore(lint): no-explicit-any in codex-app-server-agent.test * chore(lint): no-shadow in composer.test, host-runtime.test, new-workspace-screen.test * chore(lint): no-explicit-any in codex-app-server-agent.features.test * chore(lint): hoist jsx-as-prop in app components batch 1 Memoize inline JSX icons passed as props across add-host-modal, branch-switcher, composer, pair-link-modal, pr-pane, and sidebar-workspace-list to satisfy react-perf/jsx-no-jsx-as-prop. * chore(lint): no-explicit-any in session.test * chore(lint): hoist jsx-as-prop in app components batch 2 Memoize inline JSX passed as props across agent-list, agent-status-bar, file-explorer-pane, git-actions-split-button, and message to satisfy react-perf/jsx-no-jsx-as-prop. * chore(lint): hoist jsx-as-prop in app components batch 3 Memoize inline JSX passed as props across combined-model-selector, draggable-list.native, provider-diagnostic-sheet, and workspace-setup-dialog to satisfy react-perf/jsx-no-jsx-as-prop. * chore(lint): hoist jsx-as-prop in desktop components Memoize inline JSX passed as props across desktop-permissions-section, desktop-updates-section, integrations-section, and pair-device-section to satisfy react-perf/jsx-no-jsx-as-prop. * chore(lint): no-explicit-any in mcp-server.test * chore(lint): hoist jsx-as-prop in workspace/new-workspace screens * chore(lint): hoist jsx-as-prop in remaining screens * chore(lint): no-explicit-any in session.workspaces.test * chore(lint): no-explicit-any in snapshot-mutation-ownership.test * chore(lint): no-explicit-any in dictation-stream-manager.test * chore(lint): no-explicit-any in relay-transport.e2e.test * chore(lint): no-explicit-any in worktree-session.test * chore(lint): no-explicit-any in model-resolver.test * chore(lint): no-explicit-any in sherpa-parakeet-stt.test * chore(lint): no-explicit-any in speech-download.e2e.test * chore(lint): no-explicit-any in script-health-monitor.test * chore(lint): no-explicit-any in schedule/service.test * chore(lint): no-explicit-any in persistence-hooks.test * chore(lint): no-explicit-any in editor-targets.test * chore(lint): no-explicit-any in send-while-running-stuck-test-utils.test * chore(lint): no-explicit-any in agent-storage.test * chore(lint): no-nested-ternary in app batch 1 (18 files) * chore(lint): no-explicit-any in generate-sherpa-tts-matrix * chore(lint): no-explicit-any in claude-agent * chore(lint): no-explicit-any in websocket-server * chore(lint): no-explicit-any in process-conversation * chore(lint): no-explicit-any in daemon-client * chore(lint): no-explicit-any in codex-app-server-agent * chore(lint): no-nested-ternary in app batch 2 (26 files) * chore(format): apply oxfmt to server test files * chore(lint): parallelize agent archiving in test-mcp-inject * chore(lint): no-explicit-any in small app files (batch 1) * chore(lint): no-explicit-any in small app files (batch 2) * chore(lint): no-explicit-any in app (batch 3) Covers use-web-scrollbar, stream-strategy, dictation-stream-sender test, terminal-perf helper, checkout-git-actions-store test, and web-desktop-scrollbar. * chore(lint): no-explicit-any in app (batch 4) Covers composer, message-input, tooltip, workspace-desktop-tabs-row, and the e2e helpers (app, node-ws-factory, terminal-probes). * chore(lint): no-explicit-any in polyfills/crypto.ts * chore(lint): no-explicit-any in components/sidebar-workspace-list.tsx * chore(lint): prefer-array-find over filter().at/pop Replace filter(pred).at(-1)/pop() patterns with findLast(pred) and filter(pred)[0] with find(pred) across server and app. * chore(lint): no-explicit-any in components/message.tsx * chore(lint): no-explicit-any in components/plan-card.tsx * chore(lint): no-map-spread replace with Object.assign Replace { ...obj, override } inside map callbacks with Object.assign({}, obj, { override }) to satisfy oxc/no-map-spread. Preserves copy-on-write semantics. * chore(lint): no-extraneous-class in test mocks Add dispose() stubs to xterm addon mocks to satisfy typescript-eslint/no-extraneous-class, and convert static-only Notification mocks to plain objects. * chore(lint): no-named-as-default use named imports for ws and openai * chore(lint): jsx-no-new-array-as-prop hoist composed style in volume-display Memoize the style array so it is not created inline on every render. * chore(lint): prefer-add-event-listener use Object.assign for non-DOM handlers These transports (Transport interface, StreamableHTTPServerTransport) use plain on<event> properties rather than EventTarget, so addEventListener is not an option. Using Object.assign to set the handlers avoids the lint false-positive without changing behavior. * chore(lint): no-multiple-resolved null pendingResolve after settling Replace boolean-settled guards with a nullable captured resolve/reject. Each promise callback captures the resolver, nulls it on first use, and calls it. This preserves the existing single-resolution semantics while making the no-multiple-resolved rule happy. * chore(lint): reduce structural complexity in server Extract nested-callback cleanup helpers in worktree-bootstrap.test. Extract Codex model definition builder to drop list-models complexity below 20. * chore(lint): extract helpers in agent-activity and session-store-hooks.test Split tool-call update handling in groupActivities into helpers to clear max-depth. Hoist useWorkspaceFields selector in the hooks test to drop callback nesting. * chore(lint): rules-of-hooks and exhaustive-deps in agent-stream-view Move useMemo calls for permission card styles above the early return so hooks run unconditionally. Add missing dependencies to the inline path press handler and the stream render callback. * chore(lint): rules-of-hooks in diff-scroll via optional context hook Replace try/catch around useExplorerSidebarAnimation with a new useExplorerSidebarAnimationOptional hook that returns null when the provider is absent. * chore(lint): rules-of-hooks and exhaustive-deps in sidebar-workspace-list Replace conditional useMemo calls with plain inline arrays, capture creatingWorkspaceTimeoutsRef.current in the effect body before cleanup, and depend on the full input object in armTimers. * chore(lint): rules-of-hooks in split-container Hoist useWorkspaceLayoutStore and useMemo calls above the pane-kind early return so hooks always run in the same order. * chore(lint): rules-of-hooks in context-menu and dropdown-menu Inline the resolvedWidthStyle object inside the content useMemo and move the early return below the hook so it is always invoked in the same order. * chore(lint): rules-of-hooks in web-desktop-scrollbar Move thumbRegionStyle and handleStyle useMemo calls above the visibility early return. * chore(lint): reduce complexity in types/stream Split reduceStreamUpdate timeline branch into per-case helpers (tool call and compaction) to clear complexity and max-depth warnings. * chore(lint): reduce complexity in diff-highlighter Extract metadata detection, path extraction, hunk parsing, and content-line push into helpers to drop parseDiff complexity below 20. * chore(lint): exhaustive-deps in composer and use-attachment-preview-url Memoize githubSearchItems so the picker callbacks don't see a new array every render, hoist realtimeVoiceButtonStyle above rightContent useMemo that depends on it, and add missing style dependencies. Tighten use-attachment-preview-url to read the attachment via a ref while keying off stable field primitives. * chore(lint): reduce complexity in tool-call-detail-state Extract per-detail helpers for hasMeaningfulToolCallDetail to clear complexity warning. * chore(lint): reduce complexity in agent-grouping Split groupAgents into partition, project-activity map, active-project, and inactive-date helpers. * chore(lint): reduce max-depth in voice-runtime Extract retireFinishedGroup helper to flatten processPlaybackQueue nesting. * chore(lint): reduce max-depth in use-branch-switcher Extract maybeRestoreStashForBranch callback to flatten handleBranchSelect nesting. * chore(lint): exhaustive-deps in components batch Address exhaustive-deps warnings across file-explorer-pane, file-pane, git-diff-pane, message, provider-diagnostic-sheet, stream-strategy-web, terminal-emulator, terminal-pane, and volume-meter. Memoize values that otherwise changed every render, read non-reactive values through refs when the effect intentionally tracks a different key, and add missing dependencies where they were genuinely absent. * chore(lint): reduce complexity/max-depth in draft-store Extract collectQueuedMessageAttachmentIds and collectStreamUserImageIds helpers from runAttachmentGc. Extract buildMigratedDraftRecord helper for migratePersistedState. * chore(lint): reduce complexity in tooltip and workspace-scripts-button Extract resolveActualSide and resolveAlignedCoordinate helpers in tooltip. Extract resolveScriptIconColor in workspace-scripts-button. * chore(lint): exhaustive-deps in contexts and hooks batch Fixes exhaustive-deps warnings across app contexts and hooks by adding missing deps, stabilizing derived arrays with useMemo, capturing ref values at effect entry, and using ref pattern where deps were intentionally omitted. * chore(lint): final hook-rules in workspace-screen, editor-button, stores, e2e Memoizes derived arrays (availableEditors, terminals) to stabilize useMemo deps, adds missing deps (normalizedServerId, normalizedWorkspaceId, explorerToggleStyle, workspaceIdsKey, eventName), and renames the Playwright fixture callback parameter from `use` to `provide` so eslint-plugin-react-hooks doesn't conflate it with React's use() hook. * chore(lint): reduce complexity/max-nested-callbacks in workspace-tabs-store Extract migrate function body into migrateWorkspaceTabsState top-level helper with per-loop sub-helpers (migrateUiTabsForKey, mergeExplicitTabOrder, mergeLegacyTabOrder, migrateFocusedTabIds) and replace the inline IIFE in ensureTab with buildNextTabsForEnsure helper. * chore(lint): reduce complexity in session-store and panel-store Extract isSessionServerInfoUnchanged helper from updateSessionServerInfo in session-store. In panel-store split migrate body into per-version migration helpers (migratePanelV2Explorer, migratePanelV3Explorer, migratePanelExplorerTabByCheckout, migratePanelDesktopFocusMode) and a top-level migratePanelState function. * chore(lint): reduce complexity in keyboard-shortcuts and use-keyboard-shortcuts Split resolveKeyboardShortcut into resolveInitialChordStep and resolveAdvancingChordStep helpers with a shared buildMatchFromBinding factory. Split handleAction's large switch into handleDispatchOnlyAction, handlePayloadAction, handleSettingsToggle, and handleCommandCenterToggle helpers, with hasPayloadKey type guard replacing inline payload checks. * chore(lint): reduce complexity in audio recorder web hooks Extract assertMicrophoneEnvironment helper from useAudioRecorder start callback. Split useDictationAudioSource stop callback with disconnectDictationAudioGraph, stopMediaRecorderIfActive, finalizeRecorderStoppedPromise, and safeDisconnectNode helpers. * chore(lint): reduce complexity in use-git-actions * chore(lint): reduce complexity in use-pr-pane-data * chore(lint): reduce complexity in use-agent-autocomplete * chore(lint): reduce complexity in use-agent-screen-state-machine * chore(lint): reduce complexity in session-stream-reducers * chore(lint): reduce complexity in desktop-updates-section * chore(lint): reduce complexity in pair-device-section * chore(lint): reduce complexity in update-callout-source * chore(lint): reduce complexity in provider-diagnostic-sheet * chore(lint): disable no-await-in-loop (sequential-by-necessity cases) Most remaining no-await-in-loop warnings were in legitimate sequential patterns: polling loops with sleep, streaming/pagination cursors, shared mutable state, ordered side effects (audio playback, port allocation). Parallelizing these would change observable behavior. Rather than force restructures that add complexity without benefit, disable the rule. * chore(lint): reduce complexity in setup-panel Extract helpers (resolveAutoExpandIndex, resolveSetupStatusLabel, resolveCommandLog, buildCommandRowState) and lift the standalone log view and top-level error banner into dedicated sub-components to drop SetupPanel below the complexity limit. * chore(lint): reduce complexity in AssistantMarkdownImage Extract error-text resolution into a helper so the image component drops below the cyclomatic complexity threshold. * chore(lint): reduce complexity in ProjectLeadingVisual Extract the status-variant dispatch into a ProjectLeadingVisualStatus sub-component so the outer function stays below the cyclomatic complexity limit. * chore(lint): extract ChatAgentContent agent-building helper * chore(lint): reduce complexity in ChatAgentContent Extract the chat-agent selector (selectChatAgentState + resolveChatAgentFromSession), the agent-shape constructor (buildChatAgentFromState), and the not-found/error/boot view dispatch (renderChatAgentNonReadyView) into helpers so both the selector callback and the component function drop below the cyclomatic complexity limit. * chore(lint): extract subcomponents to reduce JSX nesting depth * chore(lint): reduce complexity in app components (status-bar, explorer, setup-dialog, tool-call-details) * chore(lint): reduce complexity in app hooks/runtime/stores/misc components * chore(lint): long-tail cleanup (no-async-endpoint-handlers, unicorn rules, unescaped-entities, unassigned-import allowlist) * chore(lint): simplify agent useMemo deps to match helper signature * chore(lint): rename ChatService.postMessage to dispatchMessage * chore(lint): server cleanup (no-shadow, no-useless-*, no-unmodified-loop, control-regex, require-yield) * chore(lint): app cleanup (jsx-max-depth, jsx-no-new-*-as-prop, complexity, misleading-regex, no-useless-*) * chore(lint): e2e cleanup (no-unmodified-loop-condition, max-nested-callbacks) * chore(lint): workspace-screen complexity + no-empty-pattern cleanup * chore(lint): use Array.from for defensive snapshot iteration * chore(lint): final mechanical tail (control-regex, max-depth, useless-expressions, examples cleanup) * chore(lint): reduce agent-stream-view complexity * chore(lint): reduce resolveAgentModelSelection complexity * chore(lint): reduce globalSetup complexity * chore(format): oxfmt draft-store single-line signature * chore(lint): reduce GitDiffPane complexity * chore(lint): reduce MessageInput complexity * chore(lint): reduce Combobox complexity * fix(server): bound listLinuxWatchDirectories readdir concurrency Wraps the per-level readdir traversal in listLinuxWatchDirectories with a module-level p-limit (default 16, tunable via PASEO_LINUX_WATCH_READDIR_CONCURRENCY). On broad repos, the previous Promise.all over an entire BFS level could issue an unbounded number of concurrent readdir calls. Behavior is otherwise identical: still traverses all non-.git directories and swallows per-directory readdir failures. * chore(lint): promote oxlint warnings to errors - package.json: lint/lint:fix now pass --deny-warnings so any warning fails - .github/workflows/ci.yml: add lint job running npm run lint - .oxlintrc.json: disable no-empty-pattern for e2e/fixtures.ts (Playwright requires the empty object destructure as the first arg) - packages/app/e2e/fixtures.ts: restore async ({}, provide) signature - packages/app/e2e/global-setup.ts: oxfmt single-line signature * fix(test): relay-transport ws mock exports WebSocket named binding Commit 38efad7d switched relay-transport.ts from default to named import of ws.WebSocket, but the test mock still only exported default. Updated vi.mock("ws") to return both default and named WebSocket bindings so the mocked module matches the new import shape. Classification: test drifted with production code; test now exports what the production import needs. * chore(lint): make oxlint error at config level; add Lefthook pre-commit Replaces --deny-warnings workaround with semantic severity at the config level, and adds whole-repo pre-commit gates via Lefthook. - .oxlintrc.json: all enabled categories (correctness, suspicious, perf) and intentional rule overrides now use "error" instead of "warn". Removed duplicate "require-await" key (last-wins "off" preserved). - package.json: lint scripts are plain oxlint / oxlint --fix. Adds lefthook devDep and "prepare": "lefthook install --force" so hooks install on npm install even where core.hooksPath is set globally. - lefthook.yml: pre-commit runs format:check, lint, typecheck in parallel. Whole-repo gates (no glob filters). Block-only, no auto-formatting. * fix: update lockfile signatures and Nix hash * chore(lint): pre-commit runs formatter in write mode, then lint+typecheck Switches the pre-commit hook from format:check to format (write) with stage_fixed: true, so the formatter rewrites files and re-stages them into the commit. Lint and typecheck then run in parallel against the formatted tree. Sequencing uses Lefthook 2.x jobs with a nested group: top-level jobs run sequentially, so the format job completes before the checks group starts; within checks, lint and typecheck run in parallel. CI continues to use format:check, so unformatted code pushed with --no-verify still fails on the server. * chore(lint): revert pre-commit to format:check (no stage_fixed) stage_fixed: true with a whole-repo formatter (oxfmt .) can silently re-stage the full reformatted file when a developer used git add -p to stage only a hunk, losing their hunk-level intent. Safer to just block the commit on unformatted code and let the dev run `npm run format` themselves. Reverts to the simple parallel check form: all three commands run concurrently and are read-only. * chore(ts7): tsgo compatibility across the monorepo Preserves tsc 5.9.3 behavior while making TypeScript 7 / tsgo (@typescript/native-preview 7.0.0-dev.20260423.1) green package-by-package. tsconfig: - server/tsconfig.server.json: drop removed `baseUrl`; rewrite `@server/*` paths entry to be relative to the tsconfig. - website/tsconfig.json: drop removed `baseUrl`; rewrite `~/*` paths entry to be relative. - expo-two-way-audio/tsconfig.json: replace inherited moduleResolution=node10 with `bundler`, set `module: esnext` (required by `bundler`). Matches Metro/Expo runtime behavior and avoids forcing `.js` extensions in source. source: - app/e2e/helpers/terminal-probes.ts: WebSocket subclass `send` now types its argument as `Parameters<WebSocket["send"]>[0]` so the subclass signature tracks the platform type across tsc 5.9 and TS 7 libdom. - relay/src/crypto.ts: tweetnacl setPRNG callback allocates a fresh Uint8Array for getRandomValues (owning ArrayBuffer) and copies into the caller-provided view. TS 7 libdom requires ArrayBufferView<ArrayBuffer> (not ArrayBufferLike). All 8 packages green under both tsc --noEmit and tsgo --noEmit. * fix(app): update os-notifications test mocks for addEventListener Commit 46731a51 switched attachWebClickHandler from notification.onclick to notification.addEventListener("click", ...) to satisfy the prefer-add-event-listener lint rule. The test mocks still asserted the old onclick property, so two specs failed on CI with "notification.addEventListener is not a function". Update the three MockNotification classes to record click listeners through addEventListener and drive them via clickListeners[0] in the assertions. * chore: switch typecheck from tsc to tsgo (@typescript/native-preview) Installs @typescript/native-preview 7.0.0-dev.20260423.1 as a root devDependency and swaps every per-workspace `typecheck` script from `tsc --noEmit` to `tsgo --noEmit`. Build scripts still use `tsc`, so emit behavior is unchanged. Monorepo typecheck drops from ~28s to ~4.7s wall clock (~6x faster). expo-two-way-audio previously ran `tsc` without --noEmit for its typecheck step. tsgo is stricter about rootDir on emit, so the typecheck script explicitly passes --noEmit here too. * fix: update lockfile signatures and Nix hash * fix(app): commit *.css module declaration for CI typecheck expo generates expo-env.d.ts (which references expo/types where *.css is declared) locally, but the file is gitignored. CI does a fresh checkout + install and doesn't run expo, so the declaration is missing and tsgo rejects the side-effect import '@xterm/xterm/css/xterm.css' with TS2882. Add a committed packages/app/global.d.ts with 'declare module "*.css"' so typecheck is self-contained. tsc tolerated the missing declaration more loosely; tsgo is stricter. --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>	2026-04-24 12:26:10 +08:00
Mohamed Boudra	cda3d1d46c	chore: apply oxlint fix-suggestions (unused imports + useless fragments) ... Scoped to only `no-unused-vars` and `react/jsx-no-useless-fragment` — the safe subset of --fix-suggestions. Primary changes: - Remove unused named imports from statements - Remove unused default/type imports entirely - Collapse `<><Single/></>` fragments to `<Single/>` Verified clean: typecheck + format + lint all green.	2026-04-23 21:55:25 +07:00
Mohamed Boudra	177153e5e8	chore: apply oxlint autofix (safe level) ... Auto-fixed 102 warnings (6040 → 5938) across 57 files. Main categories: - preserve-caught-error: add { cause: error } to re-thrown errors - unicorn/no-array-reverse: .reverse() → .toReversed() - unicorn/no-useless-fallback-in-spread: drop unnecessary ?? {} in spreads - oxc/no-map-spread: rewrite object spread in .map() to Object.assign - react-hooks/exhaustive-deps: trim module-level constants from dep arrays Ran npm run format after to clean up whitespace from lint mutations.	2026-04-23 21:47:36 +07:00
Mohamed Boudra	ce4b0d54c7	chore: reformat codebase with oxfmt ... Apply prettier-compatible formatting across the repo to match the incoming oxfmt configuration. Mechanical reformat only — no logic changes. Covers YAML quote normalization, package.json key sorting, Markdown/TOML formatting, and minor TS whitespace tweaks.	2026-04-23 21:44:48 +07:00