multiplat-factory 0.1.0 → 0.1.1

package/README.md

@@ -1,294 +1,83 @@
-# ⚙️ Multiplat Factory
+# multiplat-factory
 
-If you have an app that runs on one platform: the web, iOS, or Android, this Multiplat Factory will help you publish to the others. Point this tool at the app, name the platforms you want, and it builds working native apps for them, tests that they behave and look like the original, and writes up what it did. It even has design, annotation, and implementation, which can be useful for going from small screen to large.
+Port an app from one platform (web, iOS, Android) to the others. Give the factory a source
+project, pick the targets, and it analyzes the app, verifies its behaviors on the original (a dev
+server plus Chromium for web, a simulator or emulator plus Maestro for mobile), plans the port,
+generates native projects (SwiftUI, Jetpack Compose, or a web app in vanilla, React, Vue, or
+Svelte), builds and tests them against the same behaviors, has an independent critic review the
+result, and writes a `PORT.md` per target. Optionally it extracts the shared, non-UI logic into a
+Rust core compiled to WebAssembly that runs unchanged on all three platforms with golden-vector
+parity tests.
 
-It runs on your own machine, uses your own agent accounts, and you decide on the budget cap.
-
-https://github.com/user-attachments/assets/145f78c3-7b22-4a36-b986-779a44c52e98
-
-## How it works
-
-The factory reads your app's code and works out what the app does: its screens, its controls, and the things a user can do with it (we call those **behaviors**). It then runs the original app and checks each behavior really works there, so it will infer what "correct" looks like. Next it plans the port, and Claude writes the code for each new platform. The factory builds that code, installs it on a simulator or emulator or in a browser, and runs the same behaviors against it. You can speak directly to the agent within the run as well.
-
-Failures go back to the agent to fix, a limited number of times. A second, independent agent session reviews the finished port and scores it. Finally a `PORT.md` file per platform records what shipped, what passed, what failed, and what you chose to accept.
-
-There are a couple of design principles:
-
-- **An agent never decides what happens next.** The order of steps, the retry limits, the budget, and the pass or fail decisions are fixed code. The agent only writes files.
-- **Everything is checked against the real app.** Behaviors are verified on the original before anything is written, and the ports are tested with real behaviors.
-- **Leverage WASM for Portability** When your app has a good amount of logic that is not user interface (pricing rules, validation, data handling), the factory can pull that logic out into one **shared core**: a small Rust program compiled to WebAssembly that runs unchanged on web, iOS, and Android. It records the original app's real outputs for many inputs and checks the core gives the same answers on every platform.
-
-A dashboard in your browser shows all of this live: where a run is, what it is spending, what is failing, and when it needs a decision from you.
-
-## What it supports
-
-| Your app is on | It can read                                                                                                          | It produces                                                                                   |
-| -------------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
-| Web            | Vite, Next, Nuxt, SvelteKit, Angular, any npm project with build or dev scripts, or plain static HTML                | A Vite app in vanilla JavaScript, React 19, Vue 3, or Svelte 5 (you choose, or the plan does) |
-| iOS            | Xcode projects and workspaces, XcodeGen `project.yml` files, Swift packages. Swift or Objective-C. UIKit or SwiftUI. | A SwiftUI app, built and tested on the iPhone simulator                                       |
-| Android        | Gradle projects. Kotlin or Java. Views or Jetpack Compose. Multi-module and flavored builds are fine.                | A Jetpack Compose app, built and tested on a headless emulator                                |
-
-_Apps already built with a cross-platform framework (React Native, Flutter, Capacitor) are not supported_
-
-## Install
-
-The package is not on npm yet. Once it is:
-
-```bash
-npm i -g multiplat-factory
-mpf doctor
-```
-
-From a packed tarball (what the release script produces, see [Releasing and publishing](#releasing-and-publishing)):
+## Quick start
 
 ```bash
-npm i -g dist-release/multiplat-factory-0.1.0.tgz
-mpf doctor
+npm i -g multiplat-factory   # or: npx multiplat-factory doctor
+mpf doctor                     # what toolchains are present, what each gap disables (--json)
+mpf setup                      # install what doctor reports missing, asking before each step (--yes, --dry-run)
+mpf serve                      # the dashboard and API on http://127.0.0.1:4310 (--port, --host)
+mpf port ./my-app --to ios,android --budget 30
+mpf runs                       # runs so far; `mpf status <runId>` for one
 ```
 
-From source, every `mpf` command runs as `pnpm mpf <command>`:
-
-```bash
-git clone https://github.com/sdras/multiplat-factory.git
-cd multiplat-factory
-nvm use
-pnpm install
-pnpm mpf doctor
-```
-
-## Step by step instructions
-
-1. **Check the machine.** `mpf doctor` prints one line per tool and says which platforms this machine can build for. `mpf doctor --json` prints the same report as JSON.
-2. **Install what is missing.** `mpf setup` walks through the gaps doctor found and asks before running each install command (Homebrew on macOS, apt on Linux, winget on Windows). Anything that needs `sudo` runs only after you confirm that exact command. `mpf setup --yes` accepts every command that does not need sudo and prints the rest for you to run yourself. `mpf setup --dry-run` shows what would run and stops.
-3. **Start the dashboard.** `mpf serve` runs the API and the dashboard on one address, `http://127.0.0.1:4310` by default (change it with `--port`, `--host`, or `MPF_PORT`). Leave it running. If you skip this, each command starts its own copy for as long as the command runs, so the dashboard disappears when the command ends.
-4. **Port something.** `mpf port ./my-app --to ios,android` takes a folder or a git URL. It creates the run, prints a link to the run's dashboard page, and follows the run in the terminal until it finishes. The command exits with an error code unless the run succeeded or stopped where you told it to with `--until`. The first pause is plan approval: open the dashboard page, or run `mpf answer <runId> plan approve`.
-5. **Read the result.** Each platform's project is in `~/.mpf/runs/<runId>/workspace/<target>/`. Its `PORT.md` lists what shipped, every behavior and whether its test passed, the reviewer's verdict, any deviations you accepted, and the parts of the shared core that were written by hand rather than recorded from the original. `report.json` in the run's folder holds the same data for tools. `mpf status <runId>` prints a one-line summary.
-
-To rehearse the whole thing for free, with no Claude calls and no build tools:
-
-```bash
-mpf port fixtures/inhouse/web-vanilla-counter --to web,android --fake --yes
-```
-
-## Commands
-
-| Command                                          | What it does                                                                                                                                                                                              |
-| ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mpf doctor [--json]`                            | Checks Node, git, the package manager, Claude access, Xcode, Java, the Android SDK, Gradle, Rust, Maestro, and Playwright's Chromium. Says which platforms you can build for and what each gap costs you. |
-| `mpf setup [--yes] [--dry-run]`                  | Installs what doctor reports missing, asking before each step.                                                                                                                                            |
-| `mpf serve [--port <n>] [--host <h>]`            | Runs the daemon (the API, the live event stream, and the dashboard) until you stop it.                                                                                                                    |
-| `mpf port <source> --to <targets> [options]`     | Ports a folder or git URL. Options are listed below.                                                                                                                                                      |
-| `mpf runs`                                       | Lists runs with their status, source, targets, and cost.                                                                                                                                                  |
-| `mpf status <runId>`                             | Shows one run's stages and its summary.                                                                                                                                                                   |
-| `mpf resume <runId>`                             | Continues a paused run, including one that stopped at `--until`.                                                                                                                                          |
-| `mpf answer <runId> <stageId> <choice> [--note]` | Answers a stage that is waiting for you. Stage ids look like `plan`, `test:android`, or `critique:ios`.                                                                                                   |
-| `mpf rerun <runId> <stageId>`                    | Runs one stage again, plus everything after it. The rerun stages get a fresh allowance of fix rounds.                                                                                                     |
-| `mpf instruct <runId> <stageId> "<text>"`        | Leaves a note for the Claude session that will work on that stage next.                                                                                                                                   |
-
-Options for `mpf port`:
-
-- `--to web,ios,android`: the platforms to build.
-- `--budget <usd>`: the spending cap. Default 30, at most 500.
-- `--core auto|always|never`: whether to build the shared core. `auto` says no when only one platform is requested, since there is nothing to share.
-- `--web-framework vanilla|react|vue|svelte`: the framework for a web port.
-- `--until <stage>`: pause after that stage.
-- `--yes`: skip the plan approval and the pause before fix rounds.
-- `--detach`: create the run and return right away instead of following it.
-- `--fake`: run the rehearsal pipeline with no Claude calls and no build tools.
-
-A run's stages, in order (use these names for `--until` and in stage ids): `ingest`, `inventory`, `spec`, `behaviors`, `observe`, `plan`, `core.extract`, `core.vectors`, `core.build`, then for each platform `generate`, `build`, `test`, `critique`, `fix`, and finally `report`.
-
-## What you need
-
-- **Node 22.13 or newer.** The repo's `.nvmrc` asks for 24, so run `nvm use` in a source checkout. On an older Node, `pnpm` itself can fail before anything starts with the error `Cannot find matching keyid`. That is the old Corepack shim; switching Node fixes it.
-- **A way to use agents.** Either set `ANTHROPIC_API_KEY`, or log in to Claude Code on this machine (`claude`, then `/login`). Every call goes through your account and every run has a spending cap.
-- **The build tools for the platforms you want.** `mpf doctor` lists what is present. `mpf setup` installs missing build tools. In short:
-  - Web needs Playwright's Chromium, so the factory can watch the original app run.
-  - Android needs a JDK between 17 and 24, the Android SDK with an emulator and an `android-36` system image, Gradle, and Maestro (the tool that taps and types on mobile devices).
-  - iOS needs macOS with Xcode, an iOS simulator, XcodeGen, and Maestro.
-  - A shared core needs Rust with the `wasm32-unknown-unknown` target.
-
-  A platform whose tools are missing is skipped, and the run explain this.
+Requires Node 22.13 or newer. The factory uses your own Claude credentials: `ANTHROPIC_API_KEY`,
+or the Claude Code login on this machine. iOS targets need macOS with Xcode; web and Android
+targets also run on Linux. A target whose toolchain is missing is skipped with a plain reason.
 
-iOS output can only be built on macOS. Web and Android output can be built on macOS or Linux.
+The dashboard runs on your machine next to the daemon, because the factory needs this machine's
+simulators, emulators, toolchains, and Claude login. There is nothing to host. Commands start an
+embedded daemon for their own lifetime when `mpf serve` is not running.
 
-## Pauses, budgets, and stopping early
+## Porting
 
-A run can pause and wait for you at three points. Answer from the run's dashboard page or with `mpf answer`.
+`mpf port <path or git URL> --to web,ios,android` creates a run, prints its dashboard link, and
+follows it in the terminal. Options: `--budget <usd>` (default 30, at most 500; the run pauses
+when it is reached), `--core auto|always|never` for the shared WASM core (`auto` declines when
+only one target is requested), `--web-framework vanilla|react|vue|svelte`, `--until <stage>`
+(pause after that stage, for example `plan`), `--yes` (skip the plan approval and fix-loop
+checkpoints), `--detach` (create the run and return), and `--fake` (a pipeline with no LLM and
+no toolchains, to exercise the factory). Without `--detach` it exits non-zero unless the run
+succeeded or stopped where `--until` asked.
 
-- **Plan approval** (on by default; `--yes` skips it) pauses after `plan`. Choices: `approve` or `reject`.
-- **Before the first fix round** (`--yes` skips it) pauses `build` and `test` before they spend money on fixes. The pause shows the failures and how much the fix is allowed to cost. `continue` goes ahead, rebuilding or retesting first. `reject` cancels the run.
-- **Reviewer escalation** pauses when the independent review cannot settle a platform within its rounds. `accept` records the remaining problems as deviations you have chosen to live with, marked as such in `PORT.md`. `reject` cancels the run.
+Stage kinds, in order: `ingest`, `inventory`, `spec`, `behaviors`, `observe`, `plan`,
+`core.extract`, `core.vectors`, `core.build`, then per target `generate`, `build`, `test`,
+`critique`, `fix`, and finally `report`. Stage ids look like `plan`, `test:android`, or
+`critique:ios`.
 
-`--until <stage>` pauses a run after that stage. Use it to read the analysis before anything is generated (`--until plan`), or to stop after the shared core is built (`--until core.build`). `mpf resume` carries on. If the named stage is the last one, the run finishes instead of pausing.
+Each target's project lands in `~/.mpf/runs/<runId>/workspace/<target>/` with its `PORT.md`:
+what shipped, every behavior and whether its flow passed, the critic's verdict, and any accepted
+deviations.
 
-Every run has a spending cap: `--budget`, or the configured default of $30. The ceiling is $500. Cost is charged the moment a Claude session returns, and the run pauses when it reaches the cap. The CLI and the dashboard cannot raise a paused run's budget yet. From a source checkout, `pnpm tsx scripts/run-control.ts <runId> resume --budget <usd>` does it. For scale: a two-screen app costs about $15 to $40 per platform, and a dozen-screen app that talks to a live backend about $100 to $150.
+## Checkpoints
 
-## The dashboard
-
-`mpf serve` serves the dashboard and the API from one process on your machine. There is nothing to deploy. The factory needs the simulators, emulators, build tools, and Claude login of the machine it runs on, so each person runs it locally. A hosted version for many users would need the six replacement points listed in `docs/HOSTED-SEAM.md`. None of that exists yet.
-
-The pages:
-
-- `/`: all runs.
-- `/runs/new`: start a new run.
-- `/runs/<id>`: one run, with its stage graph, live transcript, budget, and controls.
-- `spec`: the app's screens and behaviors, marked with which ones were verified on the original.
-- `plan`: the port plan, with approve and reject.
-- `tests`: results per platform, with flows, screenshots, failure evidence, and the shared-core parity table.
-- `critic`: the independent review's verdicts and findings.
-- `core`: a playground for the shared core.
-- `release`: a release checklist.
-- `doctor`: the tool report.
-
-The dashboard also has review tools for a project: a chat about the project that can propose changes, a design review that drafts three concept mockups to pick from, annotation of recorded screenshots with pins and notes, and the release checklist. Applying a proposal creates a new version of the project and reruns the stages it touches. These actions are also available to browser agents as WebMCP tools on the page. `docs/PROJECT-REVIEW.md` describes all of it, and `pnpm tsx scripts/review-demo.ts <screenshot.png> <port>` runs a demo against a throwaway database. The "Host on Netlify" card on the release page is for the generated web app, not for the factory itself.
-
-When developing from source, the dashboard is not prebuilt: run the API with `pnpm mpf serve` on 4310 and the dashboard with `pnpm dev`, which reloads on changes at `http://localhost:4311` and forwards `/api` calls to the daemon. Use `localhost`, not `127.0.0.1`; the dev server listens on IPv6.
-
-## Where data lives
-
-Run data never goes inside your project. The data folder is `$MPF_HOME` if set, else `$XDG_DATA_HOME/mpf`, else `~/.mpf`. Inside:
-
-- `mpf.sqlite`: the run database. Everything that happened is stored as a log of events, and every view is rebuilt from that log.
-- `daemon.json`: the running daemon's address, so the other commands can find it.
-- `runs/<runId>/`: one folder per run:
-  - `source/`: a copy of the original app
-  - `detection.json`, `inventory.json`, `appspec.json`, `behaviorspec.json`, `portplan.json`: the analysis and the plan
-  - `observe/`: screenshots of the original app and its own test results
-  - `core/`: the shared core's Rust code, the built WebAssembly module, and the recorded inputs and outputs in `vectors/*.json`
-  - `workspace/<target>/`: the generated project, its `PORT.md`, and the test flows with their evidence
-  - `report.json`: the run's report
-  - `review/`: screenshot annotations
-- `locks/`: one lock per run and one per device. Only one process drives a run at a time, and only one process uses the simulator or the emulator at a time.
-- `jdks/`: JDKs you unpack here are found like installed ones. Some older apps come with a Gradle wrapper that needs an old JDK (Gradle 4 to 7 want JDK 8 to 16), and this lets you provide one without a package manager or sudo.
-- `cache/`.
-
-## Configuration
-
-Settings come in layers, and later layers win: built-in defaults, then `config.json` in the data folder, then `mpf.config.ts`, `.js`, or `.json` in the current folder, then environment variables.
-
-```json
-{
-  "models": { "generate": "claude-opus-5", "critic": "claude-opus-5", "cheap": "claude-sonnet-5" },
-  "effort": { "generate": "xhigh", "critic": "high" },
-  "budget": { "defaultUsd": 30 },
-  "concurrency": {
-    "agents": 3,
-    "lanes": { "xcodebuild": 1, "gradle": 1, "simulator": 1, "emulator": 1, "web": 2 }
-  },
-  "toolchain": {
-    "androidHome": "/path/to/android-sdk",
-    "javaHome": "/path/to/jdk",
-    "developerDir": "/Applications/Xcode.app/Contents/Developer",
-    "maestro": "/path/to/maestro",
-    "cargo": "/path/to/cargo"
-  },
-  "server": { "host": "127.0.0.1", "port": 4310 },
-  "dataDir": "/somewhere/else"
-}
-```
-
-The values shown are the defaults, except the `toolchain` entries. Those are empty by default because the tools are found automatically (`DEVELOPER_DIR` or `xcode-select`, `JAVA_HOME`, `ANDROID_HOME`, Homebrew folders, PATH). Fill one in only when discovery picks the wrong thing.
-
-Environment variables:
-
-- `MPF_HOME`: the data folder
-- `MPF_PORT` and `MPF_HOST`: the daemon's address
-- `MPF_BUDGET_USD`: the default budget
-- `MPF_MODEL_GENERATE`, `MPF_MODEL_CRITIC`, `MPF_MODEL_CHEAP`: which Claude models to use
-- `ANDROID_HOME` or `ANDROID_SDK_ROOT`, `JAVA_HOME`, `DEVELOPER_DIR`: where the build tools are
-- `ANTHROPIC_API_KEY`: Claude access
-- `MPF_ANDROID_AVD`: which emulator image to start. Otherwise the first one found, or `mpf-api36` if there is none.
-- `MPF_KEEP_DEVICES=1`: leave the emulator or simulator running after a run that started it
-- `PLAYWRIGHT_BROWSERS_PATH`: where Playwright keeps its browsers
-
-## Run stages
-
-1. `ingest` copies the app and works out its platform and framework.
-2. `inventory` parses the code and collects the test ids the app already has, so tests can find its controls.
-3. `spec` and `behaviors` describe the app in platform-neutral terms: its screens, controls, navigation, and the things a user can do.
-4. `observe` runs the original app and checks each behavior against it, takes screenshots, and runs the app's own test suite as a baseline. Web apps run in Chromium from a dev server or a production build. iOS and Android apps run on a simulator or emulator, driven by Maestro.
-5. `plan` decides how to build each port and whether a shared core is worth it.
-6. If so, `core.extract`, `core.vectors`, and `core.build` pull out the shared logic, record the original app's real outputs for many inputs, and compile the core.
-7. For each platform: the project is scaffolded, Claude writes the code, the factory builds it and runs the same behaviors against it, the independent reviewer scores it, and problems go back for fixing within fixed limits (three build-fix rounds, two test-fix rounds, two review rounds). A `PORT.md` sums it up.
-8. `report` runs once every platform has finished, however it finished.
-
-Devices are handled for you. The factory starts a headless emulator or an iPhone simulator when none is running, reuses one that is, clears stale system dialogs before each launch, and shuts down the devices it started when the run ends.
-
-## Troubleshooting
-
-- **`mpf doctor` says there is no Claude login, but you are logged in.** nvm keeps global commands per Node version, so a `claude` installed under another Node is not on PATH. The factory still finds the login. Either install `claude` under this Node, or ignore the line.
-- **Xcode is installed, but `xcode-select` points at the Command Line Tools.** The factory finds Xcode itself and keeps working. `sudo xcode-select -s /Applications/Xcode.app` makes Xcode the default for everything else too.
-- **Gradle fails with `java.lang.IllegalArgumentException: 27` or similar.** The JDK is newer than Gradle supports. The factory's own builds need JDK 17 to 24. Homebrew's plain `openjdk` tracks the newest release, so install `openjdk@21` instead. Run `gradle --stop` after switching JDKs. The original app's own wrapper may need an older JDK still; the factory picks one by the wrapper's version, and a JDK unpacked under `<data folder>/jdks` counts.
-- **`brew install maestro` installs the wrong thing.** The mobile testing tool is `brew trust mobile-dev-inc/tap && brew install --formula mobile-dev-inc/tap/maestro`.
-- **Web observation says "unverified".** Playwright's Chromium is missing. Run `npx playwright install chromium` (from a source checkout, `pnpm --filter @mpf/analyzer exec playwright install chromium`). The port still runs; the behaviors just are not checked against the original.
-- **Every iOS test fails at once.** A stale "Open in …?" dialog from an earlier launch is hiding the whole app. The factory dismisses it before each launch. If one is stuck, shut the simulator down.
-- **Every Android test fails at once.** A stale system dialog (an "isn't responding" prompt, a crash dialog, or an "Open with" chooser) is covering the app. The factory detects and dismisses these. If an "Open with" chooser keeps coming back, uninstall leftover `app.mpf.*` packages from the emulator.
-- **"already being driven by another process".** Only one process drives a run at a time. Stop the other one (a daemon or a `run-control` script) before resuming or rerunning here.
-- **Tests die part-way when the machine is busy.** Maestro gives up without a report under heavy load. Keep the machine quiet during device runs.
-- **The run paused on its budget.** Raise it as described under [Pauses, budgets, and stopping early](#pauses-budgets-and-stopping-early), then resume.
-
-## Developing the factory
+A run pauses for you at three checkpoints: plan approval (`approve` or `reject`), before the first
+paid fix round of a build or test stage (`continue` or `reject`; `--yes` skips both of these), and
+critic escalation, when the critic cannot settle a target within its rounds (`accept` turns the
+remaining findings into accepted deviations recorded in `PORT.md`; `reject` cancels). Answer from
+the dashboard or with the control commands:
 
 ```bash
-nvm use
-pnpm install
-pnpm mpf serve      # the API on 4310
-pnpm dev            # the dashboard with hot reload on http://localhost:4311
-pnpm test           # vitest across every package; tests that need a missing tool skip themselves
-pnpm typecheck
-pnpm lint
-pnpm format         # Prettier; `pnpm format:check` is what CI runs
-pnpm mpf <command>  # run the CLI from source
+mpf answer <runId> <stageId> <choice> [--note "..."]   # e.g. mpf answer 01M... plan approve
+mpf resume <runId>                                      # continue a paused run, or past a --until stop
+mpf rerun <runId> <stageId>                             # re-run one stage and everything after it
+mpf instruct <runId> <stageId> "text"                   # queue an instruction for a stage's next worker
 ```
 
-To drive a run without the daemon while you work on a stage, use `scripts/run-control.ts`:
-
-- `pnpm tsx scripts/run-control.ts <runId> resume|rerun <stageId>|answer <stageId> <choice> [note]|status` drives an existing run.
-- `resume` also takes `--until <stage>`, `--budget <usd>`, and `--core auto|always|never`. `rerun` takes `--approve`.
-- `pnpm tsx scripts/run-control.ts new <source> --to ios,android [--until <stage>] [--budget <usd>] [--core …] [--yes]` creates a run in this process, on the current code.
-
-Point `MPF_HOME` at the same folder the daemon serves and the run appears in the dashboard. Two more scripts help. `scripts/compile-flows.ts <runId> <target>` recompiles a platform's test flows from the stored behaviors without a device. `scripts/spike-target-scaffold.ts --target android|ios|web [--framework <flavor>] [--e2e] [--core]` scaffolds, builds, launches, runs one flow, and checks shared-core parity with no Claude calls.
-
-**Fixtures** are the sample apps the factory is tested against. `fixtures/manifest.json` pins public apps by git URL, branch, and commit. `pnpm fixtures:sync` clones them into `fixtures/.cache` and fills in missing commits; `--id <fixture>` syncs one, and `--repin` moves the pins forward. The manifest also lists the in-house fixtures under `fixtures/inhouse/`:
-
-- `web-vanilla-counter`: tiny; the shared core stays off
-- `web-vanilla-cart`: about 150 lines of pure pricing logic, made for the shared core
-- `ios-uikit-notes`: Swift, UIKit, XcodeGen spec, XCTest
-- `ios-objc-notes`: Objective-C, XCTest
-- `android-views-java-notes`: Java, XML layouts, JUnit
-
-Every in-house fixture has a test id on every interactive element, and the mobile ones ship their own unit tests, which the `observe` stage records as the `source` result. `packages/adapters/test/detect.test.ts` checks the in-house fixtures, and `fixture-matrix.test.ts` checks the synced public ones.
-
-**CI** (`.github/workflows/ci.yml`) runs on Linux and macOS: lint, the Prettier check, typecheck, the tests (with Rust and Chromium installed so the core and observe tests run), the rehearsal pipeline end to end, the dashboard build, and the bundled CLI. It also builds the four web flavors and runs one Playwright flow on each, builds the in-house mobile fixtures and runs their own tests, and syncs the public fixtures and checks they are detected correctly. Runs that use real Claude calls or real devices are not in CI.
-
-To add a platform or framework, implement `SourceAdapter` or `TargetAdapter` from `packages/adapters/src/types.ts`, register it, and add a fixture. `docs/ADAPTERS.md` walks through it. `docs/ARCHITECTURE.md` describes the design and where the code differs from it. `docs/ABI.md` is the contract between the shared core and its hosts.
-
-## Releasing and publishing
-
-The published package is `multiplat-factory`. It is built from `apps/cli`, with every `@mpf/*` package bundled in and the static dashboard copied next to it. Its npm page is `apps/cli/README.md`.
-
-1. Bump the version in `apps/cli/package.json`. The CLI reads it from there at run time, so that is the only place it lives.
-2. Build and pack: `pnpm tsx scripts/release.ts`. It builds the dashboard, bundles the CLI, runs `mpf --help` from the bundle, and packs the tarball into `dist-release/`. It prints the tarball's contents (about 1.2 MB, with source maps).
-3. Try the tarball in a clean project: `mkdir /tmp/try && cd /tmp/try && npm init -y && npm i <repo>/dist-release/multiplat-factory-<version>.tgz && npx mpf doctor && npx mpf serve`.
-4. Log in to npm with `npm login` and confirm it with `npm whoami`. The name `multiplat-factory` is unscoped, so no organization is needed.
-5. Publish: `pnpm tsx scripts/release.ts --publish`. It rebuilds, then runs `pnpm publish --access public --no-git-checks` from `apps/cli`. With two-factor auth on, npm asks for a one-time code.
-6. Check from another machine: `npm view multiplat-factory version` and `npx multiplat-factory doctor`.
-
-The package metadata and this README link to the GitHub repository. Make it public before publishing, or expect dead links.
+## Data and configuration
 
-## Layout
+Run data lives under `~/.mpf` (or `$MPF_HOME`, or `$XDG_DATA_HOME/mpf`), never inside your
+project: the SQLite run store, `runs/<runId>/` with the copied source, the analysis, the
+observation screenshots, the shared core, and each target's workspace, plus `jdks/` for JDKs you
+unpack by hand for old Gradle wrappers.
 
-- `apps/cli`: the `mpf` command
-- `apps/server`: the HTTP API, the live event stream, the run daemon, and the project review routes
-- `apps/dashboard`: the Nuxt dashboard
-- `packages/core`: schemas, the event log, the SQLite store, config, the view reducer, the stage catalog
-- `packages/orchestrator`: the stage graph, state machine, scheduler, the per-platform stages, review and fix, report, project revisions
-- `packages/harness`: finding build tools, running processes, starting and stopping devices, lanes
-- `packages/adapters`: everything that knows about a specific platform or framework: reading sources, generating targets, compiling test flows, and the shared core's host bindings
-- `packages/analyzer`: the inventory, the spec and behaviors extraction, observing the original app, planning
-- `packages/llm`: the Claude session wrapper, its sandbox rules, cost accounting, and a recorder
-- `packages/critic`: the independent review
-- `packages/wasm-core`: the Rust core template, its build runner, the Node host, the recorded vectors, and the core stages
+Toolchains are discovered (`DEVELOPER_DIR` or `xcode-select`, `JAVA_HOME`, `ANDROID_HOME`,
+Homebrew prefixes, PATH) with overrides in `~/.mpf/config.json`: `models` (`generate`, `critic`,
+`cheap`), `effort`, `budget.defaultUsd`, `concurrency`, `toolchain` (`androidHome`, `javaHome`,
+`developerDir`, `maestro`, `cargo`), `server` (`host`, `port`), and `dataDir`. Environment
+variables override the file: `MPF_HOME`, `MPF_PORT`, `MPF_HOST`, `MPF_BUDGET_USD`,
+`MPF_MODEL_GENERATE`, `MPF_MODEL_CRITIC`, `MPF_MODEL_CHEAP`, `ANDROID_HOME`, `JAVA_HOME`,
+`DEVELOPER_DIR`, `MPF_ANDROID_AVD` (the emulator image to boot), and `MPF_KEEP_DEVICES=1` (leave
+the devices a run booted running).
 
-Licensed under Apache-2.0; see `LICENSE`.
+Source code, the full guide with troubleshooting, the architecture, and the adapter interface for
+adding frameworks: https://github.com/sdras/multiplat-factory

package/dist/chunk-A5ZTNRTN.js

@@ -0,0 +1,65 @@
+// ../../packages/harness/src/exec.ts
+import { execa } from "execa";
+async function runProcess(opts) {
+  const started = Date.now();
+  const limit = opts.captureLimit ?? 2e6;
+  let out = "";
+  let err = "";
+  const execaOpts = {
+    cwd: opts.cwd,
+    env: opts.env,
+    reject: false,
+    timeout: opts.timeoutMs,
+    cancelSignal: opts.signal,
+    killSignal: "SIGTERM",
+    forceKillAfterDelay: 5e3,
+    cleanup: true,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  };
+  const child = execa(opts.command, opts.args ?? [], execaOpts);
+  child.stdout?.on("data", (b) => {
+    const s = b.toString();
+    opts.onStdout?.(s);
+    if (out.length < limit) out += s;
+  });
+  child.stderr?.on("data", (b) => {
+    const s = b.toString();
+    opts.onStderr?.(s);
+    if (err.length < limit) err += s;
+  });
+  const result = await child;
+  return {
+    command: [opts.command, ...opts.args ?? []].join(" "),
+    exitCode: result.exitCode ?? null,
+    stdout: out,
+    stderr: err,
+    durationMs: Date.now() - started,
+    timedOut: Boolean(result.timedOut),
+    cancelled: Boolean(result.isCanceled)
+  };
+}
+async function which(bin, env = process.env) {
+  const cmd = process.platform === "win32" ? "where" : "which";
+  const r = await runProcess({ command: cmd, args: [bin], env, timeoutMs: 5e3 });
+  if (r.exitCode !== 0) return void 0;
+  const first = r.stdout.split(/\r?\n/).find((l) => l.trim().length > 0);
+  return first?.trim();
+}
+async function tryOutput(command, args = [], env = process.env, timeoutMs = 15e3) {
+  try {
+    const r = await runProcess({ command, args, env, timeoutMs });
+    if (r.exitCode !== 0) return void 0;
+    return r.stdout.trim();
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  runProcess,
+  which,
+  tryOutput
+};
+//# sourceMappingURL=chunk-A5ZTNRTN.js.map

package/dist/chunk-A5ZTNRTN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../packages/harness/src/exec.ts"],"sourcesContent":["import { execa, type Options as ExecaOptions } from 'execa'\n\nexport interface RunProcessOptions {\n  command: string\n  args?: string[]\n  cwd?: string\n  env?: NodeJS.ProcessEnv\n  timeoutMs?: number\n  signal?: AbortSignal\n  onStdout?: (chunk: string) => void\n  onStderr?: (chunk: string) => void\n  /** Cap on captured output per stream, in characters. Streaming callbacks still see everything. */\n  captureLimit?: number\n}\n\nexport interface ProcessResult {\n  command: string\n  exitCode: number | null\n  stdout: string\n  stderr: string\n  durationMs: number\n  timedOut: boolean\n  cancelled: boolean\n}\n\n/**\n * Runs a child process with a timeout, kill-tree on abort, and streaming output.\n * Never throws for a non-zero exit; inspect `exitCode`.\n */\nexport async function runProcess(opts: RunProcessOptions): Promise<ProcessResult> {\n  const started = Date.now()\n  const limit = opts.captureLimit ?? 2_000_000\n  let out = ''\n  let err = ''\n  const execaOpts: ExecaOptions = {\n    cwd: opts.cwd,\n    env: opts.env,\n    reject: false,\n    timeout: opts.timeoutMs,\n    cancelSignal: opts.signal,\n    killSignal: 'SIGTERM',\n    forceKillAfterDelay: 5000,\n    cleanup: true,\n    stdin: 'ignore',\n    stdout: 'pipe',\n    stderr: 'pipe',\n  }\n  const child = execa(opts.command, opts.args ?? [], execaOpts)\n  child.stdout?.on('data', (b: Buffer) => {\n    const s = b.toString()\n    opts.onStdout?.(s)\n    if (out.length < limit) out += s\n  })\n  child.stderr?.on('data', (b: Buffer) => {\n    const s = b.toString()\n    opts.onStderr?.(s)\n    if (err.length < limit) err += s\n  })\n  const result = await child\n  return {\n    command: [opts.command, ...(opts.args ?? [])].join(' '),\n    exitCode: result.exitCode ?? null,\n    stdout: out,\n    stderr: err,\n    durationMs: Date.now() - started,\n    timedOut: Boolean(result.timedOut),\n    cancelled: Boolean(result.isCanceled),\n  }\n}\n\n/** Resolve a binary on PATH; returns undefined when absent. */\nexport async function which(\n  bin: string,\n  env: NodeJS.ProcessEnv = process.env,\n): Promise<string | undefined> {\n  const cmd = process.platform === 'win32' ? 'where' : 'which'\n  const r = await runProcess({ command: cmd, args: [bin], env, timeoutMs: 5000 })\n  if (r.exitCode !== 0) return undefined\n  const first = r.stdout.split(/\\r?\\n/).find((l) => l.trim().length > 0)\n  return first?.trim()\n}\n\n/** Run a command and return trimmed stdout, or undefined on any failure. */\nexport async function tryOutput(\n  command: string,\n  args: string[] = [],\n  env: NodeJS.ProcessEnv = process.env,\n  timeoutMs = 15_000,\n): Promise<string | undefined> {\n  try {\n    const r = await runProcess({ command, args, env, timeoutMs })\n    if (r.exitCode !== 0) return undefined\n    return r.stdout.trim()\n  } catch {\n    return undefined\n  }\n}\n"],"mappings":";AAAA,SAAS,aAA2C;AA6BpD,eAAsB,WAAW,MAAiD;AAChF,QAAM,UAAU,KAAK,IAAI;AACzB,QAAM,QAAQ,KAAK,gBAAgB;AACnC,MAAI,MAAM;AACV,MAAI,MAAM;AACV,QAAM,YAA0B;AAAA,IAC9B,KAAK,KAAK;AAAA,IACV,KAAK,KAAK;AAAA,IACV,QAAQ;AAAA,IACR,SAAS,KAAK;AAAA,IACd,cAAc,KAAK;AAAA,IACnB,YAAY;AAAA,IACZ,qBAAqB;AAAA,IACrB,SAAS;AAAA,IACT,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AACA,QAAM,QAAQ,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC,GAAG,SAAS;AAC5D,QAAM,QAAQ,GAAG,QAAQ,CAAC,MAAc;AACtC,UAAM,IAAI,EAAE,SAAS;AACrB,SAAK,WAAW,CAAC;AACjB,QAAI,IAAI,SAAS,MAAO,QAAO;AAAA,EACjC,CAAC;AACD,QAAM,QAAQ,GAAG,QAAQ,CAAC,MAAc;AACtC,UAAM,IAAI,EAAE,SAAS;AACrB,SAAK,WAAW,CAAC;AACjB,QAAI,IAAI,SAAS,MAAO,QAAO;AAAA,EACjC,CAAC;AACD,QAAM,SAAS,MAAM;AACrB,SAAO;AAAA,IACL,SAAS,CAAC,KAAK,SAAS,GAAI,KAAK,QAAQ,CAAC,CAAE,EAAE,KAAK,GAAG;AAAA,IACtD,UAAU,OAAO,YAAY;AAAA,IAC7B,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,YAAY,KAAK,IAAI,IAAI;AAAA,IACzB,UAAU,QAAQ,OAAO,QAAQ;AAAA,IACjC,WAAW,QAAQ,OAAO,UAAU;AAAA,EACtC;AACF;AAGA,eAAsB,MACpB,KACA,MAAyB,QAAQ,KACJ;AAC7B,QAAM,MAAM,QAAQ,aAAa,UAAU,UAAU;AACrD,QAAM,IAAI,MAAM,WAAW,EAAE,SAAS,KAAK,MAAM,CAAC,GAAG,GAAG,KAAK,WAAW,IAAK,CAAC;AAC9E,MAAI,EAAE,aAAa,EAAG,QAAO;AAC7B,QAAM,QAAQ,EAAE,OAAO,MAAM,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC;AACrE,SAAO,OAAO,KAAK;AACrB;AAGA,eAAsB,UACpB,SACA,OAAiB,CAAC,GAClB,MAAyB,QAAQ,KACjC,YAAY,MACiB;AAC7B,MAAI;AACF,UAAM,IAAI,MAAM,WAAW,EAAE,SAAS,MAAM,KAAK,UAAU,CAAC;AAC5D,QAAI,EAAE,aAAa,EAAG,QAAO;AAC7B,WAAO,EAAE,OAAO,KAAK;AAAA,EACvB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/dashboard/200.html

@@ -0,0 +1 @@
+<!DOCTYPE html><html  lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>multiplat-factory</title><script type="importmap">{"imports":{"#entry":"/_nuxt/DkcIzcLy.js"}}</script><link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=B612:ital,wght@0,400;0,700;1,400&family=B612+Mono:wght@400;700&family=Big+Shoulders+Display:wght@500;600;700&family=Familjen+Grotesk:wght@400;500;600;700&display=swap"><link rel="stylesheet" href="/_nuxt/entry.DRmJCmhL.css" crossorigin><link rel="modulepreload" as="script" crossorigin href="/_nuxt/DkcIzcLy.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/BSEomhaZ.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/CCMCJdY2.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/B1MQUUmA.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/BVtebpBS.js"><script type="module" src="/_nuxt/DkcIzcLy.js" crossorigin></script><link rel="prefetch" as="style" crossorigin href="/_nuxt/default.BwIDAPER.css"><link rel="prefetch" as="script" crossorigin href="/_nuxt/CFi3g9tC.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/G-IHUB_t.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/D2giJ0zb.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/BeCRcAqm.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/DxWip8Ok.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/ZdpP1Ud-.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/C6vzBuMd.js"><link rel="prefetch" as="style" crossorigin href="/_nuxt/error-404.Bq-TOqNj.css"><link rel="prefetch" as="script" crossorigin href="/_nuxt/dnzJofwx.js"><link rel="prefetch" as="style" crossorigin href="/_nuxt/error-500.xaLU7Cq-.css"><link rel="prefetch" as="script" crossorigin href="/_nuxt/RgvLL8ZL.js"><meta name="color-scheme" content="dark"><meta name="theme-color" content="#1a1917"></head><body><div id="__nuxt"></div><div id="teleports"></div><script>window.__NUXT__={};window.__NUXT__.config={public:{apiBase:"/api/v1"},app:{baseURL:"/",buildId:"1d285342-32d1-4f36-aa29-aea4bf9510b7",buildAssetsDir:"/_nuxt/",cdnURL:""}}</script><script type="application/json" data-nuxt-data="nuxt-app" data-ssr="false" id="__NUXT_DATA__">[{"prerenderedAt":1,"serverRendered":2},1793581709535,false]</script></body></html>

package/dist/dashboard/404.html

@@ -0,0 +1 @@
+<!DOCTYPE html><html  lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>multiplat-factory</title><script type="importmap">{"imports":{"#entry":"/_nuxt/DkcIzcLy.js"}}</script><link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=B612:ital,wght@0,400;0,700;1,400&family=B612+Mono:wght@400;700&family=Big+Shoulders+Display:wght@500;600;700&family=Familjen+Grotesk:wght@400;500;600;700&display=swap"><link rel="stylesheet" href="/_nuxt/entry.DRmJCmhL.css" crossorigin><link rel="modulepreload" as="script" crossorigin href="/_nuxt/DkcIzcLy.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/BSEomhaZ.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/CCMCJdY2.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/B1MQUUmA.js"><link rel="modulepreload" as="script" crossorigin href="/_nuxt/BVtebpBS.js"><script type="module" src="/_nuxt/DkcIzcLy.js" crossorigin></script><link rel="prefetch" as="style" crossorigin href="/_nuxt/default.BwIDAPER.css"><link rel="prefetch" as="script" crossorigin href="/_nuxt/CFi3g9tC.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/G-IHUB_t.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/D2giJ0zb.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/BeCRcAqm.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/DxWip8Ok.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/ZdpP1Ud-.js"><link rel="prefetch" as="script" crossorigin href="/_nuxt/C6vzBuMd.js"><link rel="prefetch" as="style" crossorigin href="/_nuxt/error-404.Bq-TOqNj.css"><link rel="prefetch" as="script" crossorigin href="/_nuxt/dnzJofwx.js"><link rel="prefetch" as="style" crossorigin href="/_nuxt/error-500.xaLU7Cq-.css"><link rel="prefetch" as="script" crossorigin href="/_nuxt/RgvLL8ZL.js"><meta name="color-scheme" content="dark"><meta name="theme-color" content="#1a1917"></head><body><div id="__nuxt"></div><div id="teleports"></div><script>window.__NUXT__={};window.__NUXT__.config={public:{apiBase:"/api/v1"},app:{baseURL:"/",buildId:"1d285342-32d1-4f36-aa29-aea4bf9510b7",buildAssetsDir:"/_nuxt/",cdnURL:""}}</script><script type="application/json" data-nuxt-data="nuxt-app" data-ssr="false" id="__NUXT_DATA__">[{"prerenderedAt":1,"serverRendered":2},1793581709535,false]</script></body></html>

package/dist/dashboard/_nuxt/2mTACkJa.js

@@ -0,0 +1,3 @@
+function e(e){return e.startsWith(`before launching`)}function t(e){if(!e)return{rest:``};let t=e.split(`
+`),n=t.findIndex(e=>e.startsWith(`A system dialog covers the app:`));return n===-1?{rest:e}:{dialog:t[n],rest:t.filter((e,t)=>t!==n).join(`
+`)}}function n(e){let t=e.split(`. `),n=t.findIndex(e=>/\breject\b/.test(e));return n<=0?[e]:[`${t.slice(0,n).join(`. `)}.`,t.slice(n).join(`. `)]}export{n,t as r,e as t};

package/dist/dashboard/_nuxt/B1MQUUmA.js

@@ -0,0 +1 @@
+import{Jt as e,Xt as t,Yt as n,a as r,bt as i,ft as a}from"./BSEomhaZ.js";import"./CCMCJdY2.js";var o=t({docsBase:e,reporters:n}),s=`$s`;function c(...e){let t=typeof e[e.length-1]==`string`?e.pop():void 0;typeof e[0]!=`string`&&e.unshift(t);let[n,c]=e;if(!n||typeof n!=`string`)throw o.NUXT_E7009({key:n});if(c!==void 0&&typeof c!=`function`)throw o.NUXT_E7007({type:typeof c});let l=s+n,u=r(),d=i(u.payload.state,l);if(c&&(u._state[l]??={_default:c}),d.value===void 0&&c){let e=c();if(a(e))return u.payload.state[l]=e,e;d.value=e}return d}export{c as t};

package/dist/dashboard/_nuxt/BD1XFGRw.js

@@ -0,0 +1 @@
+import{F as e,Gt as t,Ht as n,O as r,St as i,T as a,Z as o,w as s}from"./BSEomhaZ.js";import{f as c,o as l}from"./BeCRcAqm.js";var u=Object.assign(e({__name:`StatusLamp`,props:{status:{},label:{},strong:{type:Boolean},hollow:{type:Boolean}},setup(e){let u=e,d=s(()=>u.label??c(u.status));return(s,c)=>(o(),r(`span`,{class:n([`status`,`st-${e.status}`])},[a(`span`,{class:n([`lamp`,{live:(`isLive`in s?s.isLive:i(l))(e.status),hollow:e.hollow}])},null,2),a(`span`,{class:n({lbl:e.strong})},t(i(d)),3)],2))}}),{__name:`StatusLamp`});export{u as t};

package/dist/dashboard/_nuxt/BPFatz28.js

@@ -0,0 +1 @@
+import{D as e,F as t,Gt as n,Ht as r,M as i,N as a,O as o,St as s,T as c,Y as l,Z as u,et as d,gt as f,w as p,y as m}from"./BSEomhaZ.js";import{t as h}from"./BVtebpBS.js";import{t as g}from"#entry";import{g as _}from"./BeCRcAqm.js";import{t as v}from"./BD1XFGRw.js";import{t as y}from"./DlF4qIFG.js";var b={class:`doctor-page`},x={class:`page-head`},S={key:0,class:`readouts`},C={class:`readout`},w={class:`v mono`},T={class:`readout`},E={class:`v row`,style:{gap:`14px`}},D={class:`readout`},O={class:`v mono`},k={class:`readout`},A={class:`v`},j=[`disabled`],M={key:0,class:`callout bad`,style:{"margin-bottom":`16px`}},N={class:`body`},P={key:1,class:`boxed`},F={class:`cell`,style:{"line-height":`1.35`}},I={style:{"font-size":`13.5px`,"font-weight":`700`}},L={key:0,class:`mono small muted`},R={class:`stack check-detail`,style:{gap:`6px`}},z={key:0,class:`fix`},B=[`aria-label`,`onClick`],V={class:`tags affects`},H={key:2,class:`muted`},U=Object.assign(g(t({__name:`DoctorView`,setup(t){let g=h(),U=f(),W=f(),G=f(!1),K=f(),{now:q}=y(5e3);async function J(e=!1){G.value=!0;try{U.value=await g.get(`/doctor${e?`?refresh=1`:``}`),W.value=void 0}catch(e){W.value=e.message}finally{G.value=!1}}l(()=>J());let Y=[{id:`web`,name:`web`},{id:`ios`,name:`iOS`},{id:`android`,name:`android`}],X=p(()=>new Set(U.value?.availableTargets??[])),Z=p(()=>{if(!U.value)return``;let e=Math.max(0,Math.round((q.value-new Date(U.value.generatedAt).getTime())/1e3));return e<60?`just now`:`${Math.round(e/60)} min ago`}),Q=e=>e.fix?.brew??e.fix?.apt??e.fix?.winget??e.fix?.manual;async function $(e,t){try{await navigator.clipboard.writeText(e),K.value=t,setTimeout(()=>K.value=void 0,1500)}catch{K.value=void 0}}return(t,l)=>{let f=v,p=_;return u(),o(`div`,b,[c(`div`,x,[l[5]||=c(`div`,null,[c(`h1`,{class:`title`},`Doctor`),c(`p`,{class:`subtitle`},[i(` Toolchains found on this machine and what each one unlocks. Nothing here is configured by hand; overrides live in `),c(`code`,null,`~/.mpf/config.json`),i(`. `)])],-1),l[6]||=c(`div`,{class:`grow`},null,-1),s(U)?(u(),o(`div`,S,[c(`div`,C,[l[1]||=c(`span`,{class:`k`},`Host`,-1),c(`span`,w,n(s(U).host.os)+` / `+n(s(U).host.arch)+` · node `+n(s(U).host.node),1)]),c(`div`,T,[l[2]||=c(`span`,{class:`k`},`Targets available`,-1),c(`span`,E,[(u(),o(m,null,d(Y,e=>a(f,{key:e.id,status:s(X).has(e.id)?`ok`:`missing`,label:e.name,hollow:!s(X).has(e.id)},null,8,[`status`,`label`,`hollow`])),64))])]),c(`div`,D,[l[3]||=c(`span`,{class:`k`},`Claude backend`,-1),c(`span`,O,n(s(U).llmBackend),1)]),c(`div`,k,[l[4]||=c(`span`,{class:`k`},`Checked`,-1),c(`span`,A,n(s(Z)),1)])])):e(``,!0),c(`button`,{class:`btn`,type:`button`,disabled:s(G),onClick:l[0]||=e=>J(!0)},[a(p,{name:`refresh`}),i(n(s(G)?`Checking`:`Re-check`),1)],8,j)]),s(W)?(u(),o(`div`,M,[l[10]||=c(`span`,{class:`lamp`},null,-1),c(`div`,null,[l[9]||=c(`div`,{class:`head`},`Cannot reach the server`,-1),c(`div`,N,[i(n(s(W))+`. Start it with `,1),l[7]||=c(`code`,null,`pnpm mpf serve`,-1),l[8]||=i(`.`,-1)])])])):e(``,!0),s(U)?(u(),o(`div`,P,[l[12]||=c(`div`,{class:`head-row check-head`},[c(`span`,null,`Status`),c(`span`,null,`Check`),c(`span`,null,`Detail · fix`),c(`span`,{class:`affects`},`Affects`)],-1),(u(!0),o(m,null,d(s(U).checks,t=>(u(),o(`div`,{key:t.id,class:`check`},[a(f,{status:t.status,strong:``,hollow:t.status!==`ok`},null,8,[`status`,`hollow`]),c(`div`,F,[c(`span`,I,n(t.label),1),t.version?(u(),o(`span`,L,n(t.version),1)):e(``,!0)]),c(`div`,R,[c(`span`,{style:{"font-size":`13px`,"line-height":`1.45`},class:r(t.status===`ok`?`dim`:``)},n(t.detail),3),t.status!==`ok`&&Q(t)?(u(),o(`div`,z,[c(`code`,null,n(Q(t)),1),c(`button`,{class:`btn tiny`,type:`button`,"aria-label":`Copy the fix for ${t.label}`,onClick:e=>$(Q(t),t.id)},[a(p,{name:`copy`,size:11}),i(n(s(K)===t.id?`Copied`:`Copy`),1)],8,B)])):e(``,!0)]),c(`div`,V,[l[11]||=c(`span`,{class:`affects-label muted small`},`Used for`,-1),(u(!0),o(m,null,d(t.affects,e=>(u(),o(`span`,{key:e,class:`tag`},n(e),1))),128))])]))),128))])):s(W)?e(``,!0):(u(),o(`p`,H,`Checking toolchains…`))])}}}),[[`__scopeId`,`data-v-f46173f9`]]),{__name:`DoctorView`});export{U as t};