mirror of https://github.com/getpaseo/paseo.git synced 2026-11-04 23:44:41 +00:00

Files

T

Mohamed Boudra 4f7813d3aa Keep the tapped line in place when chat disclosures expand or collapse, with the native timeline on LegendList (#8717 )

* Keep a disclosure's trigger in place on web

Expanding or collapsing a turn summary, tool-call group, tool call details
or todo badge now holds the row that owns the trigger. Rows inside the
timeline get a disclosure context; each toggle runs its state change through
`useDisclosureHold()`, and the viewport's new `holdRow(rowId, apply)` replaces
`holdReadingPosition()`.

On web the hold pins the reading anchor to that row, stops following output,
and resumes following when the change leaves the list at its end. Native keeps
its previous behaviour (detach, then apply) until the anchored toggle lands.

* Render the native chat timeline with LegendList in forward order

The native timeline was an inverted FlatList. Disclosure toggles moved their
trigger, and a cold open settled visibly. It is now a forward-order LegendList
that stays virtualized, and one owner moves the scroll offset at a time:

- Before placement: LegendList's initial scroll, behind its hidden reveal.
- While following: the end pin (native-end-pin.tsx). This is a zero-height first
  child at the bottom of the content, which native maintainVisibleContentPosition
  keeps in place. A content shrink or growth never scrolls from JS; only a
  viewport resize or an explicit jump does.
- During a disclosure hold and while detached: LegendList MVCP with
  shouldRestorePosition (native-disclosure-hold.ts), so a toggle keeps its
  trigger at the same y and paints one layout change.
- Every newly mounted row starts at a per-kind estimate (new-row-estimates.ts).

PaseoScrollView defers React Native's content clamp while MVCP is set. A shrink
below an unmoved anchor no longer draws a frame past the end (RN #58578,
PR #58695). VisibleContentPositionClampTest covers this.

LegendList 3.7.1 patch, one "Paseo patch" comment per hunk:
- The content height comes from React state on the new architecture.
- Rows get a per-row size estimate.
- The MVCP anchor lock runs on native too. Upstream gated it to web in d24a9d93
  without a native reason. Without the lock, the size pass for prepended history
  re-anchors on a prepended row and moves the rows on screen. Native ends the
  lock when its row leaves the view, not on the 300 ms clock.
- Header and footer reveal together with the rows.
- Only lists that keep their end preserve the initial end.
- A remeasure within one pixel plus the 1/8 dp floor of the known size is
  noise. Upstream compares the raw size with the floored one, so the live
  turn's assistant row (1380 -> 1381 px) read as a resize and moved every row
  a frame after the reveal.
- The Android silent initial scroll retry sends its 1 dp nudge and the return
  to the target in one task. Upstream returns on the next frame, but its 16 ms
  check can finish the scroll first and cancel that frame, so the list revealed
  3 px short of its end and moved into place a frame later.
- The top-padding shrink hold applies on iOS only.

Android, emulator. Evidence is in .artifacts/legend-impl.
- J1, J2 at the end, J3, J4, J5, J6, J7: pass.
- J2 while streaming: not reachable on the Ten second stream fixture; its turns
  never fold.
- J8: no blank frames over 10 fresh flings, at host load 32-37.

J4: still. Before these two hunks, 6 of 7 cold opens moved every row one frame
after the reveal. After them, 9 valid cold opens show no shift. 5 of those
were traced through the nudge path. Runs that hit the dev client's startup
SIGSEGV in MountingCoordinator::pullTransaction were left out. That crash is
in the emulator's dropbox from before this work.

* Revise a history row when its turn summary line changes

LegendList renders a row again only when its item changes. The forward-order
timeline in d1f2ae352 folds a finished turn into its host user message, but the
host's item does not change when the fold appears, so a turn that folded live
lost its summary line until something else revised the row.

collapseTurns now reports the hosts whose summary line appeared, changed or went
away since the previous fold (updatedHostIds), and the history row revision
treats them as changed content.

* Stop following the end while a user scroll owns the viewport

The bottom anchor controller kept sticky-bottom for the whole of a drag and its momentum and only
decided at the end. While it is sticky the native list mounts the end pin, so a drag started during
a stream had every new line move the rows under the finger: on the iOS simulator the offset jumped
by each line's height (+22, +35, +22 pt) mid-drag, and Android does the same with the same code.

beginUserScroll now detaches. endUserScroll resumes following when the gesture ends at the end
(scrolling there without animation) and otherwise stays detached and drops any pending anchor, as
before. The re-stick is not animated: on Android a line that mounts during a smooth scroll cancels
it, and the list then followed 40 pt short of the end until the controller detached it.

Measured after the change, frame by frame:
- iOS and Android, drag up mid-stream: the content tracks the finger and momentum with no line
  steps; the stream grows below; tapping the pill re-sticks and follows again.
- A short drag at the end, mid-stream: following resumes; the release lands on the end in one
  frame (the drag distance, here 8 pt on iOS and 21 dp on Android).

A line already mounting when the drag begins can still move the rows once in its first frame,
because the detach reaches native one commit after the touch.

* Correct the iOS scroll view under maintainVisibleContentPosition

Phase 2 of the LegendList timeline. The native timeline relies on maintainVisibleContentPosition
for the end pin and the disclosure hold, and React Native 0.86 on iOS gets two cases wrong.
modules/paseo-scroll now registers PaseoScrollViewComponentView, a subclass of
RCTScrollViewComponentView, for the iOS scroll view, like PaseoScrollView on Android.

- A mount that removes its own anchor: detaching removes the end pin in the same mount that opens
  the tapped disclosure, and the offset jumped by the removed view's frame. The subclass keeps the
  offset when the anchor's tag is no longer registered, the check React Native 0.88 adds in
  https://github.com/react/react-native/pull/57294. That PR's extra superview check is not copied
  because it skips anchors detached by removeClippedSubviews
  (https://github.com/react/react-native/issues/58910).
- A shrink at the end: UIKit clamps the offset to the new end during the mount, then React Native
  adds the anchor's movement, so a turn folding while following landed above the end
  (https://github.com/react/react-native/issues/58578). The subclass restores the pre-mount offset
  for the adjustment and clamps after it, as
  https://github.com/react/react-native/pull/58695 does.

The dev client was rebuilt with the module. Verified on the iPhone 16 Pro simulator, frame by frame:
the summary far up and the latest turn's summary while following each keep the trigger at 0 px
with one layout change per toggle, the todo card the same, the cold open lands still, older
history pages keep the visible rows in place, and the keyboard, send-time shrink and streaming
stay pinned to the end.

Freshly mounted markdown on iOS paints one frame after its layout, because enriched-markdown
renders asynchronously (https://github.com/software-mansion/enriched-markdown/issues/1131). A
synchronous first render removed that frame but raised fling frame time at p90 and p99, so it is
not part of this change.

docs/agent-stream-disclosure.md now describes the clamp correction on both platforms.

* Keep the rows under the finger at a drag's start and its release

Two one-frame row movements remained around a user scroll while the timeline streams.

A drag's first frames. The end pin stays mounted until JS stops following, one round trip after
the drag begins, so a line mounting in those frames scrolled the rows under the finger by its
height. Both scroll view subclasses now skip the content-position correction while the user drags
and the anchor is the end pin, which they recognise by its native ID ("paseo-end-pin"). Android
overrides scrollToPreservingMomentum, the position keeper's only scroll call, from the begin-drag
event until the finger lifts; iOS skips the adjustment while the scroll view is dragging. The skip
is limited to the pin: LegendList's own anchoring for the detached list also uses the native
correction, and a history page landing mid-drag needs it. It starts at the drag rather than at
touch-down: a tap or long press while following would otherwise leave the list stranded short of
its end, still following, once the finger lifts.

The release. A gesture ending within 32 pt of the end re-stuck with an instant scroll, a snap of up
to 56 px. Following now resumes only when the finger lifts at or past the end, or momentum stops
there, within 1 px, the distance web resumes at (strategy-web.tsx). Anything else stays detached with the
pill. The check runs when the gesture is decided, so output that arrived below meanwhile counts. A
release past the end counts as at the end: on iOS it bounces back, and a line landing during the
bounce scrolls in as following would. endUserScroll takes isAtEnd, like releaseDisclosure.

Tests: VisibleContentPositionClampTest gains growth at the end during a drag (red before the
change: the offset moved by the 120 px growth, 352 -> 472) and growth without a touch (the pin
still follows); the module suite passes on emulator-5558, 11 tests.
bottom-anchor-controller.test.ts: a release near but short of the end stays detached.

Device, frame scans while streaming (dev clients rebuilt):
- Android, 8 slow drags with a pill tap between: no frame moves against the finger once a drag
  starts; the stream follows between drags. Three short releases 50 px short of the end stay put
  until the pill; three drags back past the end resume following.
- iOS simulator, 6 drags: no line step during any drag or its momentum. Two short releases stay
  detached with no snap; three drags past the end resume following within 0.5 s of the bounce.

* Document the LegendList timeline and remove what the inverted list left

The native section of docs/agent-stream-disclosure.md described the FlatList hold (anchor
neighbour, native child index, frame spacing, render window). It now covers why the timeline is
forward order, who owns the offset in each state, the hold and its sync layout trigger, user
scroll and release, draw distance numbers, the LegendList patch and the scroll view corrections.

Draw distance stays at 2000. The spike measured it on a chat with a 15,000 px turn expanded: 500
blanked the viewport 1.0 to 1.5 s per fling and 2000 not at all. A re-measure on the collapsed chat
(500, 1000, 1500, 2000, interleaved) blanked at no value and its jank followed host load, which
stayed between 19 and 40, so it could not separate 1000 or 1500 from 2000.

The patch file now opens with a header listing its eight hunks by purpose and linking
LegendApp/legend-list#593, which reports each one upstream. The markdown doc records the iOS
first-paint delay (software-mansion/enriched-markdown#1131).

Removed with the inverted list: PaseoScrollView's child-reveal override (a no-op without the
inverting transform) and ScrollSelectionTest, the invertedWrapper style, and the inverted-list
passages in android.md, native-text-selection.md, mobile-testing.md, floating-panels.md and
agent-stream-performance.md. model.test, layout.test and footer-spacing.test still asserted the
inverted native order and failed; they now assert forward order, and footer-spacing uses the
real strategies instead of an inverted stub.

* fix(app): show a reply's footer when the next prompt arrives on native

LegendList re-renders a mounted row only when its item or extraData changes.
When a new prompt arrives, the previous reply's footer moves from the live
auxiliary slot into that reply's layout item (completedFooter). The reply's
StreamItem keeps its identity, and renderItem is a stable event, so the row never
rendered its new layout and the footer (copy, timing, fork) disappeared until the
row remounted. FlatList had the same gap.

The history renderer is now LegendList's extraData. Its identity changes with the
history layout map, and StreamRow's memo limits the pass to rows whose layout
item changed.

* test(app): run the web disclosure hold cases in a real browser

The three hold cases simulated layout in jsdom: hand-written row heights,
scroll clamping and resize callbacks. They could pass while Chromium paints
the trigger somewhere else. They now run in Vitest browser mode with real
layout, ResizeObserver and scroll clamping. The two hold cases fail when the
hold is bypassed.

The browser project pre-bundles @tanstack/react-virtual, so its first import no
longer reloads the test mid-run. The lucide stub gains ArrowDown, which
pane-find imports.

* fix(app): let a drag end a disclosure hold on native

A drag detached the bottom controller but kept the disclosure hold. Every item
size change restarts the hold's quiet frames, including a streaming row's, so
the hold can outlive the toggle. While it lasts, shouldRestorePosition accepts
only the held row. Once the drag scrolls that row away, a history page arriving
mid-gesture gets no anchor, and the rows the reader was on move by the page's
height.

The drag now cancels the hold without releasing it. The controller keeps no hold
state of its own beyond detached, and the gesture's end decides whether following
resumes.

* perf(app): keep the scroll-to-bottom button's state out of the timeline

Opening a tool call or turn at the end of the chat now holds its trigger in
place, so the timeline detaches and the scroll-to-bottom button appears. That
visibility was useState in AgentStreamView, so showing the button re-rendered
the whole timeline view for a change only the button reads. The viewport now
writes near-bottom into a per-agent store that only the button subscribes to.

* fix(app): show the scroll-to-bottom button on native whenever following has stopped

A gesture now resumes following only when it ends within 1 px of the end, but
the button still hid within 32 px. A release 2-32 px short of the end left the
list detached with no button to return. While detached the button now hides
only at the end; while following it keeps the 32 px tolerance so content
growth that the offset trails for a frame does not flash it. The button also
updates when following starts or stops without a scroll.

* fix(app): stop the timeline jumping when the keyboard opens or closes on native

The keyboard's settled height was committed to the list after the motion, as
paddingTop on Android and contentInset.top on iOS, to keep the top of the
history reachable under the translated dock. While following, the end pin
absorbed it in the same mount. While detached or holding a disclosure, nothing
did: Android's native anchor is LegendList's ScrollAdjust view, which padding
does not move, and LegendList compensates a padding change only on iOS. Every
row jumped by the keyboard height 0.2-1 s after the keyboard settled, and back
after it closed. On send, the same commit raced the jump to the end.

The keyboard now only translates the list with the composer. The cost: while
the keyboard is open, the composer viewport clips the top keyboard-height of
the list, so the start of a short conversation is hidden until it closes.

* chore(app): describe the native timeline as LegendList in stream comments

* fix(app): keep a disclosure's trigger in place when its row is cut off at the top on native

LegendList's idsInView starts at the first fully visible row. When a turn host's prompt bubble
sat above the viewport, a disclosure hold found no anchor in the data pass (shouldRestorePosition
rejects every other row), and the size pass anchored on the row below the host instead, so the
trigger moved by the host's size change. The patch appends the partly visible rows to idsInView
after the fully visible ones, so the held row anchors while every pass that does not restrict the
anchor keeps the first fully visible row.

The browser test renders the patched native build, which vitest now aliases instead of the
package's unpatched web build.

* fix(app): let a turn's summary line collapse again after it opens

The React Compiler cached StreamRow's `renderStreamItem(layoutItem)` on the layout item and the
renderer. The revised item that useRevisedHistoryRows hands a row whose display state changed only
fed the row id, so the row reused its cached content. Opening a turn usually inserts its rows
directly below the host, which also gives the host a new layout item. When another row sits
between them, such as a compaction marker, the host kept its layout item, its summary line stayed
collapsed, and every later tap asked to open the turn again.

The renderer now takes the item it renders, so the compiler's cache keys on the revision. StreamRow
moves to its own module, which the tests compile the way Expo does.

* test(app): alias the patched LegendList build in browser tests only

Unit tests load @legendapp/list outside Vite, so the native build's react-native import skipped
the react-native-web alias and reached React Native's Flow source, failing every unit suite that
imports the native strategy.

* fix(app): keep a size-only disclosure's trigger in place when its row is cut off at the top on native

LegendList's prepareMVCP picks the anchor for a size change with no data change as the first row
in view, without asking shouldRestorePosition. A disclosure that only grows its own row (a todo
card) while that row's top was above the viewport therefore held the row below it, and the trigger
moved by the row's size change. The patch now applies shouldRestorePosition to size changes as it
already does to data changes.

* test(app): render the timeline row revision test in a real browser

The repo's unit tests do not mount components in JSDOM. The test still compiles stream-row.tsx with
the React Compiler, so it fails when a revised row ignores the item it was handed.

2026-11-04 17:21:31 +07:00

24 KiB

Raw Blame History

CLAUDE.md

Paseo is a mobile app for monitoring and controlling your local AI coding agents from anywhere. Your dev environment, in your pocket. Connects directly to your actual development environment — your code stays on your machine.

Supported agents: Claude Code, Codex, GitHub Copilot, OpenCode, Pi, Antigravity, and Muse Code.

Repository map

This is an npm workspace monorepo:

packages/server — Daemon: agent lifecycle, WebSocket API, MCP server
packages/app — Mobile + web client (Expo)
packages/cli — Docker-style CLI (paseo run/ls/logs/wait)
packages/relay — E2E encrypted relay for remote access
packages/desktop — Electron desktop wrapper
packages/website — Marketing site (paseo.sh)

Docs

docs/ is the source of truth for system-level and process-level knowledge. "The docs", "check the docs", or "check the X docs" always mean this directory — not the web. Look here before fetching anything online; the docs capture gotchas and conventions you cannot derive from the code or external sources.

At the start of non-trivial work, list docs/ and skim anything relevant to the task.

Doc	What's in it
docs/product.md	What Paseo is, who it's for, where it's going
docs/architecture.md	System design, package layering, WebSocket protocol, agent lifecycle, data flow
docs/agent-lifecycle.md	Agent states, parent/child relationships, archive semantics, tabs vs archive, subagents track
docs/data-model.md	File-based JSON persistence, Zod schemas, atomic writes, no migrations
docs/glossary.md	Authoritative terminology — UI label wins, no synonyms
docs/coding-standards.md	Type hygiene, error handling, state design, React patterns, file organization
docs/design.md	Design system — tokens, buttons, hierarchy, density, alignment rails, states, what's forbidden
docs/forms.md	Form architecture — non-React form model, form kit, load-state gating; the schedule form is the golden example
docs/hover.md	Hover — the canonical pattern (plain View + onPointerEnter/Leave, separate inner Pressable) and the three ways agents break it
docs/unistyles.md	Unistyles gotchas — `useUnistyles()` is forbidden, alternatives in order
docs/floating-panels.md	Anchored popovers — Portal/Modal escape for Android, lifecycle gates, keyboard-shared-value, status-bar offset, the flash
docs/keyboard-shortcuts.md	The binding table, per-platform key sources, badges vs routing, iOS `UIKeyCommand` limits
docs/menus.md	The menu engine — popover vs sheet, submenu pages, hover intent, when a decision earns a submenu
docs/expo-router.md	Expo Router route ownership, startup restore, and native blank-screen gotchas
docs/notifications.md	Notification tap ownership, native replay and acknowledgement, startup handoff, and payload QA
docs/file-icons.md	Material icon theme integration for the file explorer
docs/providers.md	Adding a new agent provider end-to-end
docs/forge-providers.md	Adding a git forge: registry/manifest, drop-in checklist, self-host/GHES, the two facts tiers
docs/custom-providers.md	Custom provider config: Z.AI, Alibaba/Qwen, ACP agents, profiles, custom binaries
docs/plugins.md	Local plugin manifest, directory source config, RPCs, native surfaces, and attachment sources
docs/website-i18n.md	Website languages: locale URLs, translated Markdown pairs, `{#id}` anchors, Chinese style
docs/service-proxy.md	Service proxy: exposing workspace scripts at public URLs, DNS setup, reverse proxy config
docs/relay-endpoint-security.md	Relay E2EE modes: Noise NK mapping, record framing, negotiation, the `requireProtectedSecurity` flag, close codes
docs/development.md	Dev server, build sync gotchas, CLI reference, agent state, Playwright MCP
docs/rpc-namespacing.md	WebSocket RPC naming convention — dotted namespaces and `.request`/`.response` pairs
docs/protocol-compatibility.md	Why app/daemon versions drift, protocol vs feature contract, capability gating, COMPAT tagging
docs/protocol-validation.md	zod-aot generated inbound WebSocket validation, patched compiler regressions, schema-purity rules
docs/connected-hosts.md	Daemon-owned host registrations, routed SDK scopes, identity and authority boundaries
docs/permissions.md	Semantic daemon permissions, principals, credentials, pairing invitations, and Hub authority
docs/terminal-performance.md	Terminal latency pipeline, coalescing/backpressure invariants, benchmark + perf spec usage
docs/terminal-rendering.md	Native terminal view: xterm owns the grid, cluster placement, emoji widths, mixed-direction limits, render regression
docs/agent-stream-performance.md	Assistant text pipeline — coalescing window, paced reveal, why arrival lumps are smoothed at render
docs/agent-stream-disclosure.md	Expand/collapse in the chat timeline — hold contract, native anchor sequence, frame spacing, render-window cost
docs/markdown-renderer.md	Shared Markdown engine, native selection, links, images and library constraints
docs/native-text-selection.md	Native diagram grouping, selection boundaries and leading inline image limitations
docs/file-observation.md	Recursive watcher ownership, Linux constraints, teardown invariants, and Parcel comparison
docs/testing.md	TDD workflow, determinism, real dependencies over mocks, test organization
docs/qa.md	QA evidence bar for pull requests — platform matrix, version drift, performance, UI proof
docs/mobile-testing.md	Maestro and mobile test workflows
docs/mobile-panels.md	Compact left/center/right panel ownership, worklet motion, gesture revisions, and Fabric constraints
docs/explorer-sidebar.md	Explorer sidebar, side-pane, and compact workspace sheet host contracts, lifecycle, placement, routing preferences
docs/ad-hoc-daemon-testing.md	Isolated in-process daemon test harness
docs/browser-capture-harness.md	Real-Electron browser screenshot harness and compositor-surface gotcha
docs/android.md	App variants, local/cloud builds, EAS workflows, version codes, F-Droid source builds and store metadata
docs/docker.md	Running the daemon and bundled web UI in Docker, volumes, agent images, security
docs/release.md	Release playbook, draft releases, completion checklist
docs/terminal-worker.md	Terminal worker process model, socket/record/secret, protocol-bump rule and draining, the worker's file copy, Windows desktop
docs/terminal-activity.md	Terminal activity indicators — source-agnostic tracker, agent hook reporting, adding a new hook provider
SECURITY.md	Relay threat model, E2E encryption, DNS rebinding, agent auth
public-docs/hub/security.md	Public Hub guide — trust boundaries, untrusted triggers, provider controls, and output authority

Writing docs

Integrate, don't append. Find the doc that owns the subject and rewrite the part that is now wrong. The standard failure is finishing a task and adding a paragraph to the bottom of the closest-looking doc; ten tasks later the doc is a pile of paragraphs in discovery order. docs/custom-providers.md is what that looks like.
Don't document logic. Prose that restates code drifts from the code and loses. Write down what the code can't tell you: why something is shaped the way it is, the gotcha that cost an afternoon, conventions nothing enforces, constraints that span packages or versions. If a reader could get it in two minutes by opening the file, cut it.
One fact, one doc. Every other mention is a link. If you are about to write the same paragraph in two docs, one of them is a link.
Respect the layers. CONTRIBUTING.md and this file name things and link out. Activity docs like docs/qa.md and docs/testing.md set the bar for a kind of work. Subject docs like docs/unistyles.md own one thing completely. A layer never re-explains the one below it.
One subject per doc. If the subject doesn't fit in a sentence, split the doc. A section per provider, vendor, or platform is a table plus one worked example.
Delete. Obsolete sections go. Prefer a packages/app/src/thing.ts:120 reference over a pasted block.
New doc? Add a row to the table above and link it from the docs that should send readers there.
Code-level facts belong in comments next to the code, not here.

Doc voice

Plain and short. Second person. State the rule, then the reason when the reason isn't obvious. Match the doc you're editing.

Do not:

Write a sentence to land a point. "It's not X, it's Y", "That's not a Z, that's a W", and every other setup-and-punchline shape.
Add a clause that only asserts importance: "and that matters", "which is what keeps it working", "this is critical".
Use "honest", "robust", "seamless", "powerful", "simply", "just", "delightful".
Restate something you already said, in different words, for emphasis.
Hedge with "generally", "typically", or "you may want to" when the answer is "do this".
Clear your throat: "It's worth noting that", "In order to", "This section covers".

Quick start

npm run dev                          # Start the dev daemon
npm run dev:app                      # Start Expo against the dev daemon
npm run dev:desktop                  # Start Electron desktop dev
npm run cli -- ls -a -g              # List all agents
npm run cli -- daemon status         # Check daemon status
npm run typecheck                    # Always run after changes
npm run lint                         # Always run after changes
npm run format                       # Auto-format with Biome
npm run format:check                 # Check formatting without writing

Repo dev commands use checkout-local state by default. In this checkout, PASEO_HOME resolves to .dev/paseo-home, and npm run cli -- ... targets that same dev home automatically. The packaged desktop app and production-style daemon keep using ~/.paseo on port 6767.

When Mo requests an APK, use npm run build:apk:arm64 for an ARM64 build: writes artifacts/paseo-dogfood-arm64.apk with diagnostics without starting a device; npm run build:apk builds all four Android architectures.

See docs/development.md for full setup, build sync requirements, and debugging.

Release branches

Merge normal PRs into main, including while a beta soaks or a release is being finalized. Each release builds in a short-lived release workspace from origin/main or a release tag; see release base and source.

Critical rules

NEVER restart the main Paseo daemon on port 6767 without permission — it manages all running agents. If you're an agent, restarting it kills your own process.
NEVER assume a timeout means the service needs restarting — timeouts can be transient.
NEVER add auth checks to tests — agent providers handle their own auth.
Before changing app routes, startup routing, remembered workspace restore, or active workspace selection, read docs/expo-router.md.
NEVER run the full test suite locally. The test suites are heavy and will freeze the machine, especially if multiple agents run them in parallel. Rules:
- Run only the specific test file you changed: npx vitest run <file> --bail=1
- Never run npm run test for an entire workspace unless explicitly asked.
- If you must run a broad suite, pipe output to a file and read it afterward: npx vitest run <file> --bail=1 > /tmp/test-output.txt 2>&1 then read the file.
- Never re-run a test suite that another agent already ran and reported green — trust the result.
- For full suite verification, push to CI and check GitHub Actions instead.
Add tests to existing suites and reuse their npm scripts and CI jobs instead of creating feature-specific ones.
Always run typecheck and lint after every change.
Build workspace packages before diagnosing cross-package type errors. This repo consumes generated declarations across workspaces. If typecheck fails in a package that depends on another workspace, rebuild the owning stack first so dist declarations are current:
- npm run build:client — rebuild protocol and client declarations.
- npm run build:server — rebuild highlight, relay, protocol, client, server, and CLI when server/CLI types may be stale.
- Do not patch inferred callback parameters or add local duplicate types just to silence stale declaration errors.
Run npm run format before committing. This repo uses Biome for formatting. Do not manually fix formatting — let the formatter handle it.
Always use npm scripts for linting and formatting. Do not run tools directly with npx eslint, npx oxfmt, npx oxlint, or package-local binaries. For targeted checks, pass file paths through the npm script:
- npm run lint -- packages/app/src/components/message.tsx
- npm run format:files -- CLAUDE.md packages/app/src/components/message.tsx
The protocol stays backward-compatible. Features don't have to. Read docs/protocol-compatibility.md before touching packages/protocol. The short version:
- Protocol contract (always): an old client parses messages from a new daemon, and a new daemon parses messages from an old client. New fields are optional; never narrow, never remove, never require. Wire schemas stay pure — no .transform(), .catch(), or .preprocess().
- Feature contract (per-feature): gate the capability once on server_info.features.*, then run the feature or tell the user to update the host. No fallback paths, no defensive branches.
- Every shim is tagged. // COMPAT(name): added in vX, remove after <date> at the site that has to be deleted. rg "COMPAT\(" is the cleanup backlog; untagged back-compat is permanent by accident.
- New RPCs use dotted namespaces with direction suffixes. Follow docs/rpc-namespacing.md: domain.provider.operation.request pairs with domain.provider.operation.response. Existing flat RPC names will migrate over time; don't add new ones.

Platform gating

The app runs on iOS, Android, web (browser), and web (Electron desktop). Code is cross-platform by default. Gate only when you must. Import gates from @/constants/platform.

The four gates

Gate	Type	When to use
`isWeb`	constant	DOM APIs — `document`, `window`, `<div>`, `addEventListener`, `ResizeObserver`. This is the exception, not the default.
`isNative`	constant	Native-only APIs — Haptics, `StatusBar.currentHeight`, push tokens, camera/scanner, `expo-av`.
`getIsElectron()`	cached fn	Desktop wrapper features — file dialogs, titlebar drag region, daemon management, app updates, dock badges.
`useIsCompactFormFactor()`	hook	Layout decisions — sidebar overlay vs pinned, modal vs full screen, single-panel vs split. From `@/constants/layout`.

Decision matrix

I need to...	Use
Access DOM (`document`, `window`, `<div>`, `addEventListener`)	`if (isWeb)`
Use a native-only API (Haptics, push tokens, camera)	`if (isNative)`
Use an Electron bridge (file dialog, titlebar, updates)	`if (getIsElectron())`
Switch layout between phone and tablet/desktop	`useIsCompactFormFactor()`
Show something on hover, always-visible on native	`isHovered \|\| isNative \|\| isCompact` (hover only works on web)
Gate to iOS or Android specifically	`Platform.OS === "ios"` / `Platform.OS === "android"` (rare, keep inline)

Rules

Default is cross-platform. Don't gate unless you have a specific reason.
Prefer Metro file extensions over if statements. When a module has fundamentally different implementations per platform, use .web.ts / .native.ts file extensions instead of runtime if (isWeb) branches. Metro resolves the correct file at build time — the unused platform code is never bundled. Reserve if (isWeb) for small, inline checks (a single line or a few props). If you find yourself writing a large if (isWeb) { ... } else { ... } block, split into separate files instead.
```
hooks/
  use-audio-recorder.web.ts    ← uses Web Audio API
  use-audio-recorder.native.ts ← uses expo-audio
```
Import as @/hooks/use-audio-recorder — Metro picks the right file automatically.
Use .electron.ts / .electron.tsx for Electron-only web modules. Electron is still the Metro web platform, but desktop dev/build sets PASEO_WEB_PLATFORM=electron, so Metro first looks for .electron.* files and falls back to normal .web.* files. Use this when the implementation depends on Electron-only behavior such as webviewTag, desktop preload APIs, or the Electron bridge. Keep plain browser web in .web.*, and keep native fallbacks in the base file or .native.*.
```
desktop/browser/pane/
  index.electron.tsx ← Electron <webview> implementation
  index.web.tsx      ← plain web fallback
  index.tsx          ← native fallback
```
Import as @/desktop/browser/pane — Electron desktop gets the .electron.tsx file, browser web gets .web.tsx, and native gets the native/base implementation.
NEVER use raw DOM APIs without isWeb guard. DOM APIs crash native. Casting a RN ref to HTMLElement is a red flag — ensure the block is web-only.
NEVER use onPointerEnter/onPointerLeave. They don't fire on native iOS.
Hover only works on web. React Native's onHoverIn/onHoverOut on Pressable does NOT fire on native iOS/iPad — the underlying W3C pointer events are behind disabled experimental flags. For hover-to-show UI (kebab menus, action buttons), use isHovered || isNative || isCompact so the controls are always visible on native and hover-to-show on web.
Don't use Platform.OS as a proxy for layout capabilities. Use breakpoints for layout decisions, not platform checks.
Import isWeb/isNative from @/constants/platform. Never write const isWeb = Platform.OS === "web" locally.

Debugging

Find the complete daemon logs and traces in the $PASEO_HOME/daemon.log

24 KiB Raw Blame History