peachsim 0.1.571 → 0.1.573

package/LICENSE

@@ -2,7 +2,7 @@ Proprietary Software License
 
 Copyright (c) Tamagui LLC. All rights reserved.
 
-This package (rnxsim) is proprietary software of Tamagui LLC, licensed under
+This package (peachsim) is proprietary software of Tamagui LLC, licensed under
 the rnx Software License Agreement: https://rnxsim.com/legal/license
 
 In summary (the agreement governs): personal, non-commercial use is free;

package/README.md

@@ -1,43 +1,43 @@
 # Peach
 
-The source owner for the standalone `rnx` executable and the public `rnxsim`
+The source owner for the standalone `peach` executable and the public `peachsim`
 integration library used to drive a browser-native React Native simulator.
 
 ## Overview
 
 The CLI and library are separate public artifacts. The recommended installer
-downloads one Bun-compiled `rnx` executable that needs no Node.js, npm, or Bun
-installation. The `rnxsim` npm package contains bundler plugins, testing
+downloads one Bun-compiled `peach` executable that needs no Node.js, npm, or Bun
+installation. The `peachsim` npm package contains bundler plugins, testing
 drivers, and library exports, with no command-line binary.
 
-The executable updates itself with `rnx upgrade`. Successful interactive human
+The executable updates itself with `peach upgrade`. Successful interactive human
 commands refresh a cached stable CLI version in a detached process at most once
 every 20 hours. A newer version produces one short notice on stderr, once per
 version and no more than weekly. CI, agents, JSON output, pipes, and
-noninteractive commands stay silent. Set `RNX_UPDATE_CHECK=off` to disable the
-check and notice; `rnx version` checks explicitly, while `rnx --version` remains
+noninteractive commands stay silent. Set `PEACH_UPDATE_CHECK=off` to disable the
+check and notice; `peach version` checks explicitly, while `peach --version` remains
 offline.
 
 Neither artifact contains rendering code. The canvas engine (CanvasKit
 renderer, Yoga layout, iOS/Android shell chrome, Electron shell) lives in the
 private `sootsim-engine` workspace package and is shipped at runtime as a
-versioned tarball, fetched from the contrast.dev CDN and unpacked into `~/.rnx`.
+versioned tarball, fetched from the contrast.dev CDN and unpacked into `~/.peach`.
 
 What this workspace gives you:
 
-- the standalone `rnx` CLI source and binary build, which provides the primary
+- the standalone `peach` CLI source and binary build, which provides the primary
   debugging and automation surface (inspect the UI tree, tap elements, capture
   flows, screenshot, record, run agents)
-- `rnxsim/vite` and `rnxsim/metro` — bundler plugins that serve the installed
+- `peachsim/vite` and `peachsim/metro` — bundler plugins that serve the installed
   engine runtime from your own dev server
-- `rnxsim/jump-to-source-babel` — an optional Babel plugin that annotates JSX
+- `peachsim/jump-to-source-babel` — an optional Babel plugin that annotates JSX
   with source locations so inspect mode can open the selected element in your
   editor
 - `peachsim/detox` — a drop-in Detox driver + jest preset
-- `rnxsim/sdk` — the inspect/interact verbs as a programmatic API
-- `rnxsim/bridge-contract-input` — parsers turning untrusted JSON into
+- `peachsim/sdk` — the inspect/interact verbs as a programmatic API
+- `peachsim/bridge-contract-input` — parsers turning untrusted JSON into
   bridge-contract arguments
-- `rnxsim/skills` — a registry of Contrast-flavored automation skills
+- `peachsim/skills` — a registry of Contrast-flavored automation skills
 
 Platform status: iOS is the parity baseline. Android is bootstrapped and usable
 for focused conformance slices (bundle/runtime identity, device profiles, shell
@@ -47,7 +47,7 @@ repo plan pass.
 
 ## What's in each distribution
 
-| standalone `rnx` executable | `rnxsim` npm package | private engine runtime |
+| standalone `peach` executable | `peachsim` npm package | private engine runtime |
 | --- | --- | --- |
 | CLI commands and bridge client | Vite and Metro plugins | CanvasKit renderer and Yoga layout |
 | bridge daemon host | SDK and bridge contracts | iOS/Android shell chrome, home grid, app switcher |
@@ -66,7 +66,7 @@ internally splits into shell, compositor, and tenant workers.
 
 ```mermaid
 graph TD
-  subgraph cli["rnx CLI process (short-lived, cli/)"]
+  subgraph cli["peach CLI process (short-lived, cli/)"]
     BIN["bin.ts (dispatcher + privacy choice)"]
     SETUP["commands/setup.ts (guided daemon setup)"]
     RUNTIMECMD["commands/runtime.ts (runtime install/use)"]
@@ -92,14 +92,14 @@ graph TD
     TENANTW["tenant worker (guest RN app tree)"]
   end
   subgraph build["build-time plugins (src/)"]
-    VITEONE["rnxsim/vite = vite-plugin-one.ts (serve runtime at /__soot/)"]
+    VITEONE["peachsim/vite = vite-plugin-one.ts (serve runtime at /__soot/)"]
     VITERN["sootsim() = vite-plugin.ts (RN resolver + native stubs)"]
-    METRO["rnxsim/metro = metro-plugin.ts"]
+    METRO["peachsim/metro = metro-plugin.ts"]
     COMPAT["@sootsim/compat stub-manifest (native seams)"]
     ENGINESHIM["sootsim-engine react-native shim"]
   end
-  SKILLS["rnxsim/skills registry.ts (builtin skills)"]
-  subgraph fs["~/.rnx (home-paths.ts)"]
+  SKILLS["peachsim/skills registry.ts (builtin skills)"]
+  subgraph fs["~/.peach (home-paths.ts)"]
     RTDIR["runtimes/<version>/ (engine assets)"]
     LOCK["daemon.json lockfile"]
     CFG["config.json"]
@@ -146,22 +146,22 @@ graph TD
 ```
 
 **The CLI process** (`cli/bin.ts` routes, `cli/main.ts` parses argv) lazy-imports
-exactly one command module per run. Bare `rnx` opens ConnectRN, whose simulator UI discovers
+exactly one command module per run. Bare `peach` opens ConnectRN, whose simulator UI discovers
 running React Native development servers. The first human run offers the
 recommended background service and optional Desktop app, then opens the simulator
-before asking about private diagnostics or an optional repository install. `rnx open`
+before asking about private diagnostics or an optional repository install. `peach open`
 ensures the engine runtime exists and starts a local foreground bridge when no
 daemon is reachable, then opens a `WsBridge` (`cli/ws-bridge.ts`) on **port
 7668** and sends JSON commands. Inspection/interaction verbs live in
-`cli/commands/inspect/*` and are re-exported as the programmatic `rnxsim/sdk`;
+`cli/commands/inspect/*` and are re-exported as the programmatic `peachsim/sdk`;
 the Maestro runner is `cli/bridge-flow-runner.ts`; the Detox compat driver
 is in `detox/`. Test and screenshot paths additionally use `cli/drivers/*`.
 Browser sims launch in an isolated Playwright Chrome for Testing profile;
 Electron is the native desktop surface.
 
 **The daemon is one process** — `SootSimBridgeHost` (`src/host/bridge-host.ts`).
-`rnx serve` runs it in the foreground; the background daemon is the *same
-process* wrapped with autostart and the `~/.rnx/daemon.json` lockfile. It is
+`peach serve` runs it in the foreground; the background daemon is the *same
+process* wrapped with autostart and the `~/.peach/daemon.json` lockfile. It is
 an HTTP+WS hub: sims register over WS, CLI clients connect to drive them, and
 the host forwards each command to the targeted sim and relays the reply back. It
 also serves the engine runtime over HTTP (with a self-update route), exposes
@@ -171,11 +171,11 @@ localhost. The `AgentHost` extension owns one FIFO reader per agent session and
 fans agent events out to every subscriber.
 
 During source development, each Vite bridge owns one
-`~/.rnx/dev-bridges/<port>.json` heartbeat record. CLI defaults select the
+`~/.peach/dev-bridges/<port>.json` heartbeat record. CLI defaults select the
 current `PORT_OFFSET`, then the current checkout, then the canonical `:7668`
 bridge, so concurrent worktrees cannot replace or delete one another's address.
 Each Vite shell also publishes its exact bridge at `/__sootsim/bridge`, so a
-launcher that reuses a shell from another isolated `RNX_HOME` stays in that
+launcher that reuses a shell from another isolated `PEACH_HOME` stays in that
 shell's bridge world without reading the other process's lockfile directory.
 
 **The sim** is a browser/Electron *page* launched by a CLI driver. Inside that
@@ -186,17 +186,17 @@ bridge always addresses the **shell worker**, never an undifferentiated sim.
 
 **Two distinct plugin families** round it out, and they must not be conflated:
 
-- The published **`rnxsim/vite`** (`src/vite-plugin-one.ts`, `rnxPlugin`)
-  and **`rnxsim/metro`** plugins do one thing: serve the installed runtime at
+- The published **`peachsim/vite`** (`src/vite-plugin-one.ts`, `rnxPlugin`)
+  and **`peachsim/metro`** plugins do one thing: serve the installed runtime at
   `/__soot/` so an app's own dev server can host the sim shell. The Vite plugin accepts an
   opt-in `open` option that launches a named Electron window when the dev server
-  starts (skipped when `CI` or `RNX_NO_OPEN` is set).
+  starts (skipped when `CI` or `PEACH_NO_OPEN` is set).
 - The internal **`sootsim()`** plugin (`src/vite-plugin.ts`) is a separate, much
   larger RN-resolution / native-stub plugin: it aliases `react-native` to the
   engine shim and native packages to `@sootsim/compat` stubs, applies worklets
   transforms, and is the one that instantiates `SootSimBridgeHost` inside its
   own dev server. It is used to build the engine/shell and to load external RN
-  apps — it is **not** the published `rnxsim/vite` export.
+  apps — it is **not** the published `peachsim/vite` export.
 
 ## Key components
 
@@ -204,60 +204,60 @@ bridge always addresses the **shell worker**, never an undifferentiated sim.
 | --- | --- | --- |
 | Peach CLI (bin + dispatcher) | Short-lived terminal entry point. Parses argv, owns the private-by-default one-time choice, lazy-imports one command per run, and routes direct open/runtime/inspection flows. | `cli/bin.ts`, `cli/main.ts`, `cli/privacy.ts`, `cli/parse-args.ts`, `cli/help.ts`, `cli/commands/setup.ts`, `cli/commands/control.ts` |
 | WsBridge client | Client side of the CLI→daemon link. Resolves the daemon port from the lockfile, opens a WS to `:7668`, sends JSON commands and awaits `{id,result}`/`{id,error}`. Used by every interactive command. | `cli/ws-bridge.ts`, `src/bridge-constants.ts`, `cli/current-sim.ts` |
-| inspect / SDK command surface | Runtime inspection + interaction verbs (describe, find, do tap, get errors, wait, layout, settle). Re-exported as `rnxsim/sdk` so programmatic callers drive a sim the same way the CLI does. | `cli/commands/inspect/core.ts`, `cli/commands/inspect/actions.ts`, `cli/commands/inspect.ts`, `src/sdk.ts` |
+| inspect / SDK command surface | Runtime inspection + interaction verbs (describe, find, do tap, get errors, wait, layout, settle). Re-exported as `peachsim/sdk` so programmatic callers drive a sim the same way the CLI does. | `cli/commands/inspect/core.ts`, `cli/commands/inspect/actions.ts`, `cli/commands/inspect.ts`, `src/sdk.ts` |
 | bridge-contract input parsers | Turn untrusted JSON into typed bridge-contract arguments, so a transport in front of a sim validates request bodies once instead of writing a second reader. | `src/bridge-contract-input.ts`, `src/bridge-contract.ts` |
 | Maestro / Detox runners | Drop-in test compatibility. `bridge-flow-runner.ts` runs Maestro YAML and recorded flows over the bridge; `detox/` provides a `by`/`element`/`expect`/`device` driver + jest preset so existing Detox suites run unchanged. | `cli/bridge-flow-runner.ts`, `cli/commands/maestro.ts`, `cli/commands/detox.ts`, `detox/index.ts`, `detox/jest-preset.cjs` |
 | sim drivers | Launch or attach the actual sim page. Playwright owns isolated browser profiles; Electron owns the native desktop surface. The current sim is reused unless `--new`, `--profile`, or `--ephemeral` requests a separate one. | `cli/drivers/index.ts`, `cli/drivers/registry.ts`, `cli/drivers/electron.ts`, `cli/drivers/playwright.ts` |
-| SootSimBridgeHost (serve/daemon) | The bridge process (`rnx serve`, or autostarted as the daemon via launchd/systemd). HTTP+WS hub on `:7668`: relays commands between CLI clients and registered sims; also serves runtime HTTP, `/__server-scan`, and fetch/WS proxies. | `src/host/bridge-host.ts`, `cli/commands/serve.ts`, `cli/commands/daemon.ts`, `src/home-paths.ts` |
+| SootSimBridgeHost (serve/daemon) | The bridge process (`peach serve`, or autostarted as the daemon via launchd/systemd). HTTP+WS hub on `:7668`: relays commands between CLI clients and registered sims; also serves runtime HTTP, `/__server-scan`, and fetch/WS proxies. | `src/host/bridge-host.ts`, `cli/commands/serve.ts`, `cli/commands/daemon.ts`, `src/home-paths.ts` |
 | AgentHost + sessions | Agent-routing extension of the host: owns the single FIFO reader per agent session and fans `agent:event`/`session-status` pushes to every WS subscriber. Backed by agent-sessions + attached-projects stores. | `src/host/agent-host.ts`, `src/agent-sessions.ts`, `src/attached-projects.ts`, `src/agent-daemon-client.ts` |
 | host proxies + dev-server scan | Host-side helpers so a cross-origin tenant worker can reach local dev servers and same-origin APIs: `/__server-scan` discovers running metro/expo/vxrn/one servers; fetch + websocket proxies relay guest-app network through the daemon. | `src/host/fetch-proxy-handler.ts`, `src/host/websocket-proxy.ts`, `scripts/dev-server-scanner.ts`, `src/dev-bundle-resolution.ts` |
-| runtime delivery + Peach home | Versioned engine runtime management. The shared machinery owns manifest fetch, sha256 verification, channels, and auto-update. Peach binds it to `https://contrast.dev` and `~/.rnx/runtimes/<version>`. A repo can select `runtimeVersion` without changing the machine default. | `src/runtime-delivery.ts`, `packages/contrast-runtime-delivery/`, `src/home-paths.ts`, `src/runtime-assets.ts` |
+| runtime delivery + Peach home | Versioned engine runtime management. The shared machinery owns manifest fetch, sha256 verification, channels, and auto-update. Peach binds it to `https://contrast.dev` and `~/.peach/runtimes/<version>`. A repo can select `runtimeVersion` without changing the machine default. | `src/runtime-delivery.ts`, `packages/contrast-runtime-delivery/`, `src/home-paths.ts`, `src/runtime-assets.ts` |
 | standalone CLI delivery | Cached stable-version checks, bounded interactive notices, and verified atomic executable replacement. | `cli/cli-update.ts`, `cli/commands/upgrade.ts`, `cli/commands/version.ts`, `src/cli-version.ts` |
-| `rnxsim/vite` + `rnxsim/metro` (runtime serving) | Published bundler plugins. Both serve the installed engine runtime at `/__soot/` from `~/.rnx/runtimes/<version>` so an app's own dev server can host the sim shell; the Vite plugin can opt into a named Electron window. | `src/vite-plugin-one.ts`, `src/metro-plugin.ts`, `src/runtime-assets.ts` |
-| `sootsim()` vite resolver plugin (internal) | The large RN-resolution / native-stub vite plugin: aliases `react-native` to the engine shim, native packages to `@sootsim/compat` stubs, applies worklets/babel transforms, and instantiates `SootSimBridgeHost` in its dev server. Distinct from the published `rnxsim/vite` export. | `src/vite-plugin.ts`, `src/worklets-babel.ts`, `packages/peach-compat/src/stub-manifest.ts` |
-| skills registry | Peach agent skills (`rnx-setup`, `rnx-debug`, `rnx-test`, `rnx-visual`, and the generated `contrast` index) installable with `rnx skill`. | `skills/*.md`, `src/skills/registry.ts`, `src/skills/types.ts` |
+| `peachsim/vite` + `peachsim/metro` (runtime serving) | Published bundler plugins. Both serve the installed engine runtime at `/__soot/` from `~/.peach/runtimes/<version>` so an app's own dev server can host the sim shell; the Vite plugin can opt into a named Electron window. | `src/vite-plugin-one.ts`, `src/metro-plugin.ts`, `src/runtime-assets.ts` |
+| `sootsim()` vite resolver plugin (internal) | The large RN-resolution / native-stub vite plugin: aliases `react-native` to the engine shim, native packages to `@sootsim/compat` stubs, applies worklets/babel transforms, and instantiates `SootSimBridgeHost` in its dev server. Distinct from the published `peachsim/vite` export. | `src/vite-plugin.ts`, `src/worklets-babel.ts`, `packages/peach-compat/src/stub-manifest.ts` |
+| skills registry | Peach agent skills (`rnx-setup`, `rnx-debug`, `rnx-test`, `rnx-visual`, and the generated `contrast` index) installable with `peach skill`. | `skills/*.md`, `src/skills/registry.ts`, `src/skills/types.ts` |
 
 ## Getting started
 
 ```sh
 curl -fsSL https://rnxsim.com/install.sh | sh
-rnx                 # open ConnectRN and choose a running app in the simulator
-rnx open /settings  # dispatch a React Native deep link into that app
+peach                 # open ConnectRN and choose a running app in the simulator
+peach open /settings  # dispatch a React Native deep link into that app
 ```
 
 Start Metro, Expo, One, or another supported React Native development server
-the way you normally do, then run `rnx` from any directory. The simulator
+the way you normally do, then run `peach` from any directory. The simulator
 opens ConnectRN, which shows the available local apps and lets you connect one.
-Pass a target to `rnx open <port-or-url>` when a script or agent needs an explicit
+Pass a target to `peach open <port-or-url>` when a script or agent needs an explicit
 selection.
 
-The first `rnx open` launches an isolated Chrome for Testing sim. The CLI
+The first `peach open` launches an isolated Chrome for Testing sim. The CLI
 resolves Playwright from the app or CLI install, asks that exact package for
 its required browser executable, and runs that package's installer once when
 the executable is absent. It never substitutes another revision found in the
 shared Playwright cache. Later opens reuse that sim and reload it at the
-requested target. Use `rnx do reload` when the target has not changed.
+requested target. Use `peach do reload` when the target has not changed.
 Reserve `--new` for a genuinely concurrent sim; repeated new browser trees
 consume memory and CPU on shared machines.
 
-The public installer places one standalone `rnx` executable in `~/.local/bin`.
-The `rnxsim` npm package contains bundler plugins and library exports, not a CLI
+The public installer places one standalone `peach` executable in `~/.local/bin`.
+The `peachsim` npm package contains bundler plugins and library exports, not a CLI
 binary. Start your Metro, Expo, or One dev server the way you already do, then
 open it from the CLI. There is no iOS native build in the inner loop; Metro alone is
 enough. The manifest bundle path and query remain authoritative. When both the
 discovery request and manifest target are loopback addresses, Peach keeps the
 loopback host that answered discovery so an IPv6-only listener is not reopened
-through an unreachable IPv4 address. `rnx open` starts a local bridge when no
+through an unreachable IPv4 address. `peach open` starts a local bridge when no
 daemon is reachable. The background service is strongly recommended for local
 agent work because inspect, interaction, and test commands reuse one ready bridge
-and runtime. Enable it at any time with `rnx daemon install`; it is never required
+and runtime. Enable it at any time with `peach daemon install`; it is never required
 in CI. The packaged Desktop app is optional and available through first-run
-onboarding or `rnx desktop install`. A downloaded app starts its own bundled
+onboarding or `peach desktop install`. A downloaded app starts its own bundled
 daemon on first launch, then offers **Install the Peach command** over the running
-simulator. That action installs `~/.local/bin/rnx`, updates shell startup, and
+simulator. That action installs `~/.local/bin/peach`, updates shell startup, and
 hands the daemon to launchd or systemd without reloading the window. Windows
-keeps the desktop-owned daemon because it has no daemon service yet. Native Electron windows created by `rnx open` belong to that CLI
-session and close when the session exits; `rnx desktop` keeps the persistent
+keeps the desktop-owned daemon because it has no daemon service yet. Native Electron windows created by `peach open` belong to that CLI
+session and close when the session exits; `peach desktop` keeps the persistent
 desktop-app lifecycle. In Electron, `File > New Window`
 duplicates the focused simulator, while `File > New Simulator >` opens a new
 window for a selected device (same device list as the `Window >` menu).
@@ -268,7 +268,7 @@ Peach sends no analytics, crash report, command event, app data, project data, o
 identity by default. An unsigned-in interactive run may request the runtime it
 is about to execute and the stable standalone CLI version document. The latter
 runs after the command in a detached process at most once every 20 hours and can
-be disabled with `RNX_UPDATE_CHECK=off`. The first human run asks once about
+be disabled with `PEACH_UPDATE_CHECK=off`. The first human run asks once about
 bounded diagnostics, defaults to no, and never prompts in a non-TTY shell, CI,
 or an agent. An automated first run is declined for that process without
 consuming the later human choice. Legacy browser and Electron telemetry senders
@@ -281,13 +281,13 @@ login, upload, billing, issue reporting, generated flows, and screenshot decks
 contact their documented service only when explicitly invoked. The complete
 enforced network contract is in [`specs/rnx-privacy.md`](../../specs/rnx-privacy.md).
 
-`rnx daemon uninstall` removes the machine daemon: it stops current and legacy
+`peach daemon uninstall` removes the machine daemon: it stops current and legacy
 launchd / systemd services and removes their logs, launcher, and generated
-`.app` wrapper. `~/.rnx/` survives, because runtimes, device profiles and their
+`.app` wrapper. `~/.peach/` survives, because runtimes, device profiles and their
 app storage, and live dev-bridge records belong to simulators the user may
-still be running. `rnx daemon uninstall --purge` deletes `~/.rnx/` as well.
+still be running. `peach daemon uninstall --purge` deletes `~/.peach/` as well.
 Neither form removes the optional `/Applications/rnx.app` desktop bundle or the
-macOS preference plist. To inspect existing disk usage first, run `rnx cleanup`;
+macOS preference plist. To inspect existing disk usage first, run `peach cleanup`;
 add `--apply` only after reviewing the preview.
 
 ## Jump to source in inspect mode
@@ -299,7 +299,7 @@ Metro/Babel config:
 ```js
 plugins: [
   [
-    'rnxsim/jump-to-source-babel',
+    'peachsim/jump-to-source-babel',
     {
       include: [__dirname],
     },
@@ -340,46 +340,46 @@ inspection, interaction, animation debugging, shell tracing, screenshots, and
 flow capture, not just as a test runner.
 
 ```sh
-rnx list              # connected tabs
-rnx open 8081         # load a running metro/expo dev server
-rnx open /settings    # route via React Native Linking
-rnx describe          # dump UI tree
-rnx get errors 5      # recent runtime failures
-rnx compat            # scan native package compatibility
-rnx report-issue "…"  # preview an opt-in compatibility report
-rnx find --testid cta # inspect one node deeply
-rnx debug enable animated,layout
-rnx debug trace shell on 240
-rnx do tap-text "..." # interact
-rnx do tap email --then type user@example.com --then tap submit
-rnx debug snapshot before
-rnx debug snapshot after
-rnx debug diff before after
-rnx maestro start     # begin a Maestro draft
-rnx maestro keep      # persist the last action
-rnx maestro end --output .maestro/login.yaml --validate
-rnx detox             # run Detox/Jest suites against rnx
+peach list              # connected tabs
+peach open 8081         # load a running metro/expo dev server
+peach open /settings    # route via React Native Linking
+peach describe          # dump UI tree
+peach get errors 5      # recent runtime failures
+peach compat            # scan native package compatibility
+peach report-issue "…"  # preview an opt-in compatibility report
+peach find --testid cta # inspect one node deeply
+peach debug enable animated,layout
+peach debug trace shell on 240
+peach do tap-text "..." # interact
+peach do tap email --then type user@example.com --then tap submit
+peach debug snapshot before
+peach debug snapshot after
+peach debug diff before after
+peach maestro start     # begin a Maestro draft
+peach maestro keep      # persist the last action
+peach maestro end --output .maestro/login.yaml --validate
+peach detox             # run Detox/Jest suites against rnx
 ```
 
-See the full command reference via `rnx --help` or at
+See the full command reference via `peach --help` or at
 `src/features/site/docs/rnx/cli/` in the Contrast repo.
 
 Sim-scoped commands use the primary fallback only when one driveable sim is
 connected. With multiple driveable sims, the bridge lists their ids and refuses
-to choose. Run `rnx use <id>` to pin later commands, or pass `--sim <id>` to
+to choose. Run `peach use <id>` to pin later commands, or pass `--sim <id>` to
 target one command.
 
-Use an inline `rnx do` chain for a short action sequence that should execute as
+Use an inline `peach do` chain for a short action sequence that should execute as
 one engine batch. Repeat `--then` before each additional action. Each phrase
 uses the same positional grammar as its standalone `do` command. Touch timing
 stays inside the sim, the batch stops at the first failure, and `--json` prints
 the complete per-step result. Reusable file-based flows stay in Maestro YAML.
 
 ```sh
-rnx do tap email --then type user@example.com --then tap submit
+peach do tap email --then type user@example.com --then tap submit
 ```
 
-## Bundler plugins (`rnxsim/vite` and `rnxsim/metro`)
+## Bundler plugins (`peachsim/vite` and `peachsim/metro`)
 
 The Vite plugin serves the installed Peach runtime from your existing dev server.
 
@@ -451,8 +451,8 @@ no code changes — just add one line to your jest config:
 Or use the CLI directly:
 
 ```sh
-rnx detox            # auto-discovers e2e/ tests and launches a shell
-rnx detox init       # scaffold a config + sample test
+peach detox            # auto-discovers e2e/ tests and launches a shell
+peach detox init       # scaffold a config + sample test
 ```
 
 See `../../docs/migrating-from-detox.md` for details.
@@ -463,10 +463,10 @@ Maestro is Peach's single YAML test surface. Point it at your existing
 `.maestro/` directory, generate a test, or author one from live actions:
 
 ```sh
-rnx maestro                      # discover .maestro/ and run all flows
-rnx maestro test .maestro/       # explicit
-rnx maestro generate "verify login"
-rnx maestro --list-compat        # see the verb support matrix
+peach maestro                      # discover .maestro/ and run all flows
+peach maestro test .maestro/       # explicit
+peach maestro generate "verify login"
+peach maestro --list-compat        # see the verb support matrix
 ```
 
 Most Maestro verbs work out of the box (`tapOn`, `assertVisible`, `inputText`,
@@ -479,22 +479,22 @@ need real device hardware (GPS, radio, photo library) throw a clear error. See
 For animation-heavy debugging, the useful path is usually:
 
 ```sh
-rnx debug enable animated
-rnx debug trace shell on 240
-rnx debug snapshot before
+peach debug enable animated
+peach debug trace shell on 240
+peach debug snapshot before
 # reproduce the transition
-rnx debug snapshot after
-rnx debug diff before after
-rnx screenshot --with-frame --output /tmp/rnx-framed.png
-rnx record --duration 5 --output /tmp/rnx-anim.mp4
+peach debug snapshot after
+peach debug diff before after
+peach screenshot --with-frame --output /tmp/rnx-framed.png
+peach record --duration 5 --output /tmp/rnx-anim.mp4
 ```
 
-`rnx screenshot --with-frame` composes the real Peach shell device chrome
+`peach screenshot --with-frame` composes the real Peach shell device chrome
 around the raw screen bitmap (reusing the shell bezel/button geometry, excluding
 the Electron top bar, rail gutter, and other window chrome). Flows can request
 the framed export inline without changing Maestro syntax:
 
-`rnx wait ready` and the screenshot readiness guard accept inspectable
+`peach wait ready` and the screenshot readiness guard accept inspectable
 native content, a populated node tree, or a live-frame channel whose publish
 count advances across probes. Canvas-only GL, WebGPU, and video surfaces can
 therefore prove that they are painting without weakening the boot-card guard.
@@ -506,7 +506,7 @@ therefore prove that they are painting without weakening the boot-card guard.
     withFrame: true
 ```
 
-For plan-driven app-store exports, use `rnx screenshot appstore`:
+For plan-driven app-store exports, use `peach screenshot appstore`:
 
 ```yaml
 app: 8081
@@ -529,14 +529,14 @@ compose:
 ```
 
 ```sh
-rnx screenshot appstore --plan .rnx/app-store.yaml
+peach screenshot appstore --plan .peach/app-store.yaml
 ```
 
 The plan runner can reuse a visible sim for capture (`--sim a9`), stop after
 raw/framed intermediates (`--capture-only`), or rerender final marketing
 canvases from an existing raw directory (`--compose-only`). If your flow already
 writes screenshots to explicit project paths, set `from:` + `pathMode: flow` so
-`rnx screenshot appstore` respects the flow's own `takeScreenshot` paths
+`peach screenshot appstore` respects the flow's own `takeScreenshot` paths
 instead of prepending `--screenshots <rawDir>`:
 
 ```yaml
@@ -553,7 +553,7 @@ frame for quick art-direction passes.
 
 ## Skills registry
 
-`rnx skill install` installs Peach agent skills in the standard
+`peach skill install` installs Peach agent skills in the standard
 `<skill-name>/SKILL.md` layout used by Codex and Claude Code. The bundled
 skills cover setup, debugging/perf/accessibility, testing, visual review, and
 the generated `contrast` command index. The published CLI registry and generated
@@ -576,10 +576,10 @@ Peach's CDN origin (default `https://contrast.dev`, overridable in
 them to the shared delivery machinery in `@contrast/runtime-delivery` — an
 internal workspace package the CLI bundles, so a published install has it
 inlined. That machinery fetches `runtimes/manifest.json` + the runtime tarball,
-verifies its sha256, and unpacks it under `~/.rnx`:
+verifies its sha256, and unpacks it under `~/.peach`:
 
 ```
-~/.rnx/
+~/.peach/
 ├── runtimes/
 │   ├── <active>/         unpacked engine assets (served at /__soot/)
 │   └── <rollback>/       previous version for rollback
@@ -593,7 +593,7 @@ verifies its sha256, and unpacks it under `~/.rnx`:
 ```
 
 The bridge daemon serves these assets over HTTP and exposes a self-update route;
-`rnx upgrade` / `rnx runtime` drive explicit version changes from the
+`peach upgrade` / `peach runtime` drive explicit version changes from the
 CLI side. Installation retains the active runtime plus one rollback and removes
 the downloaded archive after extraction. Disposable Playwright caches live in a
 bounded per-session temporary directory; Electron's persistent HTTP cache is
@@ -601,11 +601,11 @@ disabled for simulator profiles and globally capped for app chrome. Cookies,
 localStorage, IndexedDB, service workers, recordings, and captured frames are
 user-owned data and are not removed by the default cleanup command.
 
-Per-repo configuration is optional. Every installed-runtime `rnx open`
+Per-repo configuration is optional. Every installed-runtime `peach open`
 serves its selected version from a version-specific localhost origin, so a
 background activation cannot mix an already loaded shell with chunks from the
 next runtime. Without config, each new open selects the active stable version.
-When `rnx.config.ts` sets `runtimeVersion`, `rnx open` installs that
+When `rnx.config.ts` sets `runtimeVersion`, `peach open` installs that
 version without changing the machine default. App config, native-linked fonts,
 and splash assets all resolve from the project root advertised by the selected
 development server. Bare Metro, which has no Expo manifest project root, uses
@@ -620,7 +620,7 @@ maintenance process. The app and terminal command are usable before the legacy
 filesystem scan begins. The worker prints the reclaimed size to stderr, records
 completion, and does not run the scan again. Open browser profiles and a runtime
 served by a live daemon or development bridge are left untouched. The automatic
-pass retries on a later command after they close. The explicit `rnx cleanup --aggressive`
+pass retries on a later command after they close. The explicit `peach cleanup --aggressive`
 command remains the only path that removes the rollback runtime or user-created
 recordings.
 
@@ -633,7 +633,7 @@ for the current platform:
 bun run build:cli-binary
 ```
 
-The output is `dist-bin/rnx-<platform>-<arch>`. `dist-cli/bin.js` remains a
+The output is `dist-bin/peach-<platform>-<arch>`. `dist-cli/bin.js` remains a
 repository build artifact for tests and internal tooling and is not published
 as an npm executable. Library exports build to `dist-lib/` (consumed via the
 `exports` map: `.`, `./vite`, `./metro`, `./sdk`, `./skills`, `./detox`, and the

package/cli/app-config.ts

@@ -65,7 +65,7 @@ export async function loadRNXAppConfig(
     })
     const loaded: unknown = await jiti.import(project.configPath, { default: true })
     if (!isRNXConfig(loaded)) {
-      throw new Error('the default export must be an rnx config object')
+      throw new Error('the default export must be a peach config object')
     }
     return resolveConfigReplacementFiles(loaded, project.configPath)
   } catch (error) {

package/cli/app-fonts.ts

@@ -124,7 +124,7 @@ export function discoverNativeLinkedAppFonts(opts: {
 
   // @react-native-vector-icons links fonts from its configured local font
   // directory and each installed icon package into the native app. those files
-  // never enter the metro module graph, so rnx must stage them through the
+  // never enter the metro module graph, so peach must stage them through the
   // same native-linked font wire as expo-font config-plugin assets. Font Awesome
   // Pro installs its licensed faces under the local directory rather than
   // publishing them in the npm package.
@@ -260,9 +260,9 @@ export function discoverNativeLinkedAppFonts(opts: {
 
 // resolve a metro dev server's project root. expo serves a manifest at the
 // server origin carrying `extra.expoClient._internal.projectRoot` — the absolute
-// dir of the app being served. the local `rnx open <port>` path runs from the
+// dir of the app being served. the local `peach open <port>` path runs from the
 // CLI's cwd, which almost never owns the bundle being opened (e.g.
-// `rnx open 8081` run from ~/soot against a 3pc metro), so scanning cwd for
+// `peach open 8081` run from ~/soot against a 3pc metro), so scanning cwd for
 // font declarations finds nothing.
 //
 // a bare react-native packager serves no such manifest, so the same resolver
@@ -355,7 +355,7 @@ export type FetchedAppFont = {
 // fetch every config-plugin font declared on an engine `?appFonts=` wire.
 // these typefaces live in the native binary, never in the metro bundle's
 // __packager_asset graph, so neither asset capture nor recorded fetches see
-// them — both the preview (`rnx record upload`) and build (`rnx app-fonts
+// them — both the preview (`peach record upload`) and build (`peach app-fonts
 // stage`) paths backfill by re-fetching the declared urls off the still-live
 // metro. one implementation so both pipelines store identical bytes + keys.
 export async function fetchAppFontFiles(

package/cli/auth.ts

@@ -1,10 +1,10 @@
-// rnx cli auth resolution for cloud-hitting commands.
+// peach cli auth resolution for cloud-hitting commands.
 //
 // priority order (first match wins):
-//   1. RNX_API_KEY — ci path
+//   1. PEACH_API_KEY — ci path
 //   2. CONTRAST_INSTALLATION_TOKEN/GITHUB_TOKEN + repo env — github action
 //      preview uploads from the Contrast runner, no extra secret
-//   3. desktop session token from shared desktop auth (`rnx login`)
+//   3. desktop session token from shared desktop auth (`peach login`)
 //
 // callers wanting an auth header: `authHeaderOrExit('upload')`.
 
@@ -14,7 +14,7 @@ import {
 } from '../src/auth/shared-session.ts'
 import { rnxExit } from './run-rnx.ts'
 
-export type CliApiKeyEnvName = 'RNX_API_KEY'
+export type CliApiKeyEnvName = 'PEACH_API_KEY'
 
 export type CliAuth =
   | { kind: 'api-key'; secret: string; source: 'env'; envName: CliApiKeyEnvName }
@@ -35,7 +35,7 @@ export type CliAuth =
       token: string
       origin: string
       // the account this sign-in bills cloud sessions to. null when the person
-      // belongs to several accounts and has not chosen one with `rnx login
+      // belongs to several accounts and has not chosen one with `peach login
       // --account`; a person with exactly one account never has to choose.
       accountId: string | null
     }
@@ -58,7 +58,7 @@ function looksLikeGitHubToken(token: string | undefined): boolean {
   // in src/github/token.ts. the length floor + prefix is only a cheap typo
   // guard before the cloud endpoints verify real repo access. an upper cap
   // here silently rejects the long actions token, so resolveCliAuth() returns
-  // null and every CI `record start` dies with "set RNX_API_KEY".
+  // null and every CI `record start` dies with "set PEACH_API_KEY".
   return Boolean(
     token &&
     token.length >= 20 &&
@@ -108,7 +108,7 @@ function isCliApiKeySecret(secret: string): boolean {
 }
 
 function readApiKeyFromEnv(): { secret: string; envName: CliApiKeyEnvName } | null {
-  const envName = 'RNX_API_KEY'
+  const envName = 'PEACH_API_KEY'
   const secret = process.env[envName]?.trim()
   return secret && isCliApiKeySecret(secret) ? { secret, envName } : null
 }
@@ -140,7 +140,7 @@ export function resolveCliAuth(): CliAuth | null {
 }
 
 export const CHOOSE_ACCOUNT_HINT =
-  'this sign-in belongs to several accounts; run `rnx login --account <name>` to choose the one to bill'
+  'this sign-in belongs to several accounts; run `peach login --account <name>` to choose the one to bill'
 
 // the account a request that opens a paid cloud session names. an api key
 // names its own account, so it sends none; a session token has to say.
@@ -175,10 +175,10 @@ export function authHeaderOrExit(commandLabel: string): {
   if (auth) return { auth, header: authHeaderValue(auth) }
 
   process.stderr.write(
-    `\n  rnx ${commandLabel} needs to be authenticated.\n\n` +
+    `\n  peach  needs to be authenticated.\n\n` +
       `  pick one:\n` +
-      `    • run \`rnx login\` to sign in with your GH account\n` +
-      `    • set RNX_API_KEY=sk_rnx_... (recommended for CI)\n\n`,
+      `    • run \`peach login\` to sign in with your GH account\n` +
+      `    • set PEACH_API_KEY=sk_rnx_... (recommended for CI)\n\n`,
   )
   rnxExit(1)
 }