Livewire

Real Chromium ↔ real HTTP bridge ↔ real engine. No mocks, no fixtures. The GUI runs in a regular Chrome tab; every invoke() / listen() goes over the bridge to the bundled endstate.exe binary. The same DevTools you'd use on a webapp (network panel, console, evaluate, snapshots) work on the real production code path.

Input: short description of what to do. Examples:

• /livewire smoke the backup subscribe flow
• /livewire drive setup with dry-run and confirm no UAC fires
• /livewire hot-iterate on the subscription banner — change copy, see it live

Modes (pick before driving)

• Smoke — verify a flow works end-to-end against the real engine. Order: curl envelope checks first (cheap, proves protocol), then UI drive. Section Smoke below.
• Dev — iterate on the GUI with the real engine wired up. Vite HMR hot-reloads frontend changes; the bridge persists. Section Dev below.
• Debug — reproduce a real-engine bug. Drive to the failure, inspect state via evaluate, scrub network/console panels. Section Debug below.

All three share the same launch + watcher + hazard handling.

---

Pre-flight (always)

1. Check sibling engine version. The bridge speaks to whatever endstate.exe is bundled in src-tauri/binaries/. If a recent engine command is needed, pull the sibling and force a rebuild:

   git -C ../endstate fetch --tags
   git -C ../endstate checkout v<X.Y.Z>
   rm -f src-tauri/binaries/endstate-x86_64-pc-windows-msvc.exe
   node scripts/rebuild-engine.cjs

   Verify the binary has what you need: ./src-tauri/binaries/endstate-x86_64-pc-windows-msvc.exe <cmd> --help
2. Direct envelope check (smoke mode only — cheap ground truth, no Tauri): ./src-tauri/binaries/endstate-x86_64-pc-windows-msvc.exe backup subscribe --json Treat those bytes as the assertion target.

Launch the bridge

3. Clear orphan listeners on 1420 + 9876 first. Earlier crashed runs often leave Vite still listening on 1420 (npm doesn't reap it) or stranded sockets on 9876. Without this check, the launch fails silently: Vite errors with "Port 1420 is already in use" and exits via beforeDevCommand, OR the Tauri bridge fails to bind and keeps running without it (no crash signal, no success signal — watcher waits forever).

   for P in $(netstat -ano | grep "LISTENING" | grep -E ":(1420|9876) " | awk '{print $NF}' | sort -u); do
     taskkill //F //PID "$P" 2>/dev/null || true
   done
   sleep 1
   netstat -ano | grep "LISTENING" | grep -E ":(1420|9876) " || echo "ports clear"

   The awk '{print $NF}' is load-bearing — $5 is LISTENING, not the PID. On Git Bash, //F //PID (double-slash) prevents Msys from mangling the args into paths.
4. Run SKIP_ENGINE_BUILD=1 npm run dev:bridge in the background. This starts Vite (1420) + the standalone endstate-dev-bridge binary (9876) — a non-Tauri process that links none of the native GUI stack. (npm run tauri:dev:browser is now an alias for dev:bridge.) First run compiles the bridge crate (fast; usually already built). ENDSTATE_ROOT defaults to the sibling ../endstate repo; override via env if needed.
5. Arm a single-shot watcher that emits when ANY of these signals land:

   until grep -qE "Browser bridge listening|Browser bridge failed to bind|error\[|panicked|exited" /tmp/dev-bridge.log; do
     sleep 2
   done

   Run that in run_in_background:true with a 5-minute timeout. The bind-failure literal is Browser bridge failed to bind port 9876 — match the prefix so it works across OS-error wording.

STABILITY — the dev bridge no longer runs inside Tauri. The intermittent ~12% 0xc0000374 heap corruption (see memory/project_tauri_dev_server_crash.md) lived in the native GUI layer (tao/wry/webview2-com) that the in-process bridge dragged in. The standalone endstate-dev-bridge binary links none of it (cargo tree -p endstate-dev-bridge shows no tao/wry/webview2-com), so that crash surface is structurally gone. If the bridge process dies now, it's a real bug in our (safe) Rust or the engine subprocess — investigate it, don't write it off as "the known Tauri flake."

Response policy:

• In smoke mode, curl is enough for envelope-shape verification. Do the curl pass first so you have protocol proof regardless of whether the UI drive lands.
• In dev mode, if the bridge dies mid-iteration, relaunch — Vite HMR and engine/keychain state persist. But also capture the stderr: a standalone-bridge crash is now signal, not noise.

Tool choice — chrome-devtools MCP is primary

First check ToolSearch with +chrome devtools to see if the mcp__plugin_chrome-devtools-mcp_* tools are loaded. Use them by default (real DevTools artifacts: list_network_requests for the network panel, list_console_messages for console, take_snapshot for uid-based a11y trees, evaluate_script for arbitrary JS, get_network_request for request/response bodies). If chrome-devtools isn't connected this session, use mcp__plugin_playwright_playwright__* as fallback and note that in the report. Don't mix the two in one session. (See [feedback-chrome-devtools-over-playwright].)

Open the GUI in Chromium (separate from Tauri's webview)

6. mcp__plugin_chrome-devtools-mcp_chrome-devtools__new_page(url="http://127.0.0.1:1420")

   Don't drive the Tauri webview window itself — chrome-devtools MCP can't attach to WebView2. Both webviews talk to the same bridge, so a separate Chromium is fine and gives you full DevTools access.

---

Smoke mode

The verification flow. Order matters — curl first, drive after.

7. Curl engine_is_running through the bridge:

   curl -sS -X POST http://127.0.0.1:9876/api/invoke \
     -H 'Content-Type: application/json' \
     -d '{"cmd":"engine_is_running","args":{}}'

   Expect {"ok":true,"data":false}.
8. Curl the engine command itself. Dispatch goes through endstate_exec — exe is __bundled__ in bundled mode, args are the engine subcommand flags. The response embeds the engine envelope in data.stdout as a JSON string:

   curl -sS -X POST http://127.0.0.1:9876/api/invoke \
     -H 'Content-Type: application/json' \
     -d '{"cmd":"endstate_exec","args":{"exe":"__bundled__","args":["backup","--json","subscribe"]}}' \
     | python -c "import sys,json; print(json.dumps(json.loads(json.load(sys.stdin)['data']['stdout']), indent=2))"

   Compare to step 2's ground-truth bytes — they should match.
9. Drive Chromium through the flow. Use the command palette (Ctrl+K → "Go to <pane>") — sidebar is hidden on landing/save/setup (intent pages). Take a snapshot, click the target, then immediately check list_network_requests({resourceTypes: ["fetch"]}) for the POST(s) to 127.0.0.1:9876/api/invoke — that's proof the click round-tripped through the real bridge.
10. Capture screenshot for the report:

    take_screenshot({filePath: ".claude/scratch/livewire-<step>.png", fullPage: false})