Polish public README

Author: AdamWentworth

.prettierignore

@@ -11,3 +11,4 @@ __pycache__
 .pytest_cache
 resources/models.json
 src-tauri/icons
+docs/assets/*.svg

README.md

@@ -1,111 +1,187 @@
 # Track Extract
 
-Track Extract is a local-first desktop prototype for AI stem separation. It is aimed at producers, engineers, DJs, remixers, and creators who need a cleaner workflow than dependency-heavy command-line wrappers: import audio, choose a curated separation task, run an offline job, preview stems, and export DAW-ready files.
+<p align="center">
+  <img src="src-tauri/icons/icon.png" width="96" alt="Track Extract app icon" />
+</p>
 
-This repository currently implements a Tauri + React desktop shell backed by a Python-first Track Extract engine. Rust is now a thin Tauri bridge for app paths, process spawning, cancellation, local media preview, and event forwarding. Python owns projects, sessions, jobs, model registry state, model installs, catalog sync, and separation providers.
+<p align="center">
+  <strong>Local-first desktop stem separation for producers, engineers, DJs, remixers, and creators.</strong>
+</p>
 
-## Current Prototype Scope
+<p align="center">
+  <a href="https://github.com/AdamWentworth/TrackExtract/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/AdamWentworth/TrackExtract/actions/workflows/ci.yml/badge.svg" /></a>
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-2ec4d6" /></a>
+  <img alt="Status: Prototype" src="https://img.shields.io/badge/status-prototype-f7c948" />
+  <img alt="Tauri 2" src="https://img.shields.io/badge/Tauri-2-24c8db" />
+  <img alt="Python Engine" src="https://img.shields.io/badge/engine-Python-73d18b" />
+</p>
 
-- Tauri 2 desktop shell with React and TypeScript.
-- Thin Rust/Tauri bridge with Python-owned app state.
+Track Extract is a desktop-first app for local AI stem separation. The goal is a cleaner workflow than
+dependency-heavy command-line wrappers: import audio, choose a curated workflow, run an offline render, preview the
+generated stems, and export DAW-ready files with predictable names and folders.
+
+The current prototype uses a Tauri + React desktop shell with a Python-owned ML engine. Rust stays intentionally thin:
+it handles desktop plumbing, command/event forwarding, local media serving, path resolution, and process cancellation.
+Python owns projects, sessions, jobs, model registry state, installs, catalog sync, and separation providers.
+
+<p align="center">
+  <img src="docs/assets/workflow.svg" alt="Track Extract producer workflow" />
+</p>
+
+## Current Status
+
+Track Extract is usable as a development prototype, not a polished end-user release.
+
+What works today:
+
+- Desktop app shell with React, TypeScript, Tauri 2, and a thin Rust bridge.
+- Browser-based development view on the same local engine state as the desktop window.
 - Drag/drop and file-picker audio import.
 - Project/session folder creation under `TrackExtract Projects`.
-- JSON model registry copied into app data on first launch.
 - Job queue with queued, preparing, running, complete, failed, and cancelled states.
-- Python engine providers for Demucs, audio-separator, and stub/test renders.
-- audio-separator catalog sync for discovering supported local model filenames.
-- Expanded model registry with Demucs runtime presets, downloadable public UVR model files, MVSEP catalog references, source links, license notes, and not-yet-supported backend candidates.
-- Managed model installer for downloadable catalog entries, with app-data storage and progress events.
-- Stem preview and export flows wired through stable Tauri commands.
+- Python providers for Demucs, audio-separator, and stub/test renders.
+- Model registry with Demucs presets, downloadable public UVR entries, MVSEP references, source links, and license notes.
+- audio-separator catalog sync for discovering local model filenames.
+- Stem preview and export flows through stable Tauri commands.
+- Multi-step workflow plumbing for curated vocal cleanup chains.
 
-The MVP does not include real-time separation, a DAW plugin, cloud processing, account logic, payments, or a production model downloader.
+Not included yet:
+
+- No DAW plugin.
+- No real-time separation.
+- No cloud processing, account system, payments, or subscription logic.
+- No fully packaged Python runtime for non-developer installs yet.
 
 ## Architecture
 
-The canonical engine source lives in `engine/src`, packaged as `trackextract_engine`. It exposes `python -m trackextract_engine` for the Rust bridge and future CLI/service work. Rust is limited to the Tauri shell and local desktop plumbing.
+<p align="center">
+  <img src="docs/assets/architecture.svg" alt="Track Extract runtime architecture" />
+</p>
 
-See [docs/architecture.md](docs/architecture.md) for the command/event flow and backend boundaries.
+The canonical engine source lives in `engine/src`, packaged as `trackextract_engine`. It exposes
+`python -m trackextract_engine` for the Rust bridge and future CLI/service work.
 
-## Repository Layout
+| Layer        | Role                                                                                  |
+| ------------ | ------------------------------------------------------------------------------------- |
+| `src/`       | React + TypeScript UI for workspace, models, workflows, jobs, preview, and export.    |
+| `src-tauri/` | Tauri desktop shell, Rust command bridge, event forwarding, cancellation, media URLs. |
+| `engine/`    | Python ML/workflow engine for projects, sessions, jobs, providers, installs.          |
+| `resources/` | Bundled model and workflow registries copied into app data.                           |
+| `schemas/`   | JSON schemas for model, workflow, and session formats.                                |
+| `scripts/`   | Setup, validation, formatting, linting, testing, and registry-generation helpers.     |
+| `docs/`      | Architecture, development, packaging, and model-registry notes.                       |
 
-- `src/`: React/TypeScript frontend.
-- `src-tauri/`: Tauri 2 shell, command bridge, event forwarding, cancellation, and local media server.
-- `engine/`: Python engine source, tests, and package metadata. This is the product engine.
-- `resources/`: Bundled model and workflow registries copied into app data.
-- `schemas/`: JSON schemas for documented registry/session formats.
-- `scripts/`: Setup, validation, and test entrypoints.
-- `docs/`: Architecture, development, model-registry, and packaging notes.
+See [docs/architecture.md](docs/architecture.md) for command/event flow and backend boundaries.
 
-## Build
+## Quick Start
 
-Install Rust stable and the Tauri prerequisites for your OS. On Ubuntu-like Linux systems, Tauri also needs WebKit/RSVG/AppIndicator development packages:
+Install JavaScript dependencies:
 
 ```bash
-sudo apt update
-sudo apt install pkg-config libdbus-1-dev libwebkit2gtk-4.1-dev build-essential curl wget file libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev
+npm install
 ```
 
-Then install JavaScript dependencies and run the app:
+Create the managed Python engine environment:
 
 ```bash
-npm install
-npm run tauri dev
+scripts/setup-trackextract-engine.sh
 ```
 
-To enable the Python engine in development, create the managed environment:
+Run the desktop app:
 
 ```bash
-scripts/setup-trackextract-engine.sh
+npm run tauri dev
 ```
 
-Track Extract auto-detects `.venv-trackextract-engine/bin/python` when launched from this repo. To force a specific Python environment, set `TRACKEXTRACT_ENGINE_PYTHON`. For NVIDIA CUDA support in audio-separator, install/update the environment with `TRACKEXTRACT_AUDIO_SEPARATOR_EXTRA=gpu`; for Windows DirectML, use `TRACKEXTRACT_AUDIO_SEPARATOR_EXTRA=dml`.
+Track Extract auto-detects `.venv-trackextract-engine/bin/python` when launched from this repo. To force a specific
+Python environment, set `TRACKEXTRACT_ENGINE_PYTHON`.
 
-See [docs/development.md](docs/development.md) for toolchain pins, environment overrides, and local check commands.
+For NVIDIA CUDA support through audio-separator, build the engine environment with the GPU extra:
+
+```bash
+TRACKEXTRACT_AUDIO_SEPARATOR_EXTRA=gpu scripts/setup-trackextract-engine.sh
+```
 
-For browser-only UI iteration with mock project/job data:
+For Windows DirectML:
 
 ```bash
-npm run dev:browser
+TRACKEXTRACT_AUDIO_SEPARATOR_EXTRA=dml scripts/setup-trackextract-engine.sh
 ```
 
-When the dev server is running on `http://localhost:1420`, both the Tauri desktop window and a normal browser tab use the same local Python engine bridge. Imports, current project/session state, jobs, generated stems, and model/workflow registry changes are shared between both views during development.
+## Linux Tauri Prerequisites
 
-If you launch the dev terminal from the Snap build of VS Code and see a `libpthread`
-symbol lookup error when Tauri starts, run the clean environment helper instead:
+On Ubuntu-like Linux systems, Tauri needs WebKit/RSVG/AppIndicator development packages:
 
 ```bash
-npm run tauri:dev:clean
+sudo apt update
+sudo apt install pkg-config libdbus-1-dev libwebkit2gtk-4.1-dev build-essential curl wget file libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev
 ```
 
-For the full local suite, use:
+If Tauri is launched from the Snap build of VS Code and hits a `libpthread` symbol lookup error, use:
 
 ```bash
-npm run check
+npm run tauri:dev:clean
 ```
 
-Network checks for model download URLs are kept opt-in so local tests are not flaky:
+## Browser Development
+
+For browser UI iteration:
 
 ```bash
-TRACKEXTRACT_TEST_NETWORK=1 npm run test:all
+npm run dev:browser
 ```
 
-## Model Registry
+When the Vite server is running on `http://localhost:1420`, both the Tauri desktop window and a normal browser tab use
+the same local Python engine bridge. Imports, current project/session state, jobs, generated stems, model installs, and
+workflow changes are shared during development.
+
+## Models And Workflows
 
-The generated bundled registry lives at `resources/models.json`, and source fragments live under `resources/models/`.
+The generated bundled registry lives at `resources/models.json`. Source fragments live under `resources/models/`.
 
 ```bash
 npm run models:build
 npm run test:models
 ```
 
-See [docs/model-registry.md](docs/model-registry.md) for registry structure, model sources, and install-state semantics.
+Model entries can represent:
+
+- Installed local providers, such as Demucs runtime presets.
+- Direct-download public model files.
+- audio-separator installable filenames.
+- Source references for models that need licensing/artifact follow-up before Track Extract can install them directly.
+
+Workflow presets live in `resources/workflows.json`. The UI also supports custom named workflows.
+
+See [docs/model-registry.md](docs/model-registry.md) for registry structure, source notes, and install-state semantics.
+
+## Checks
+
+Run the full local suite:
+
+```bash
+npm run check
+```
+
+This runs formatting checks, frontend linting, Python linting, Rust clippy, model/workflow validation, Python engine
+tests, frontend tests, production frontend build, and Rust tests.
+
+Network checks for model download URLs are opt-in so local tests are not flaky:
+
+```bash
+TRACKEXTRACT_TEST_NETWORK=1 npm run test:all
+```
 
 ## Roadmap
 
-1. Bundle/package the Python engine cleanly for end users.
+1. Package the Python engine cleanly for end users.
 2. Expand audio-separator catalog sync into curated installable workflows.
 3. Improve multi-step vocal cleanup execution.
-4. Add native ONNX Runtime only for models where it clearly improves packaging or acceleration.
-5. Better batch processing, cancellation, and resumable jobs.
-6. DAW export templates for Ableton, Logic, Pro Tools, Reaper, and FL Studio.
-7. Future VST3/AU bridge plugin that talks to the same offline Track Extract engine.
+4. Add native ONNX Runtime only where it clearly improves packaging or acceleration.
+5. Improve batch processing, cancellation, and resumable jobs.
+6. Add DAW export templates for Ableton, Logic, Pro Tools, Reaper, and FL Studio.
+7. Explore a future VST3/AU bridge plugin that talks to the same offline Track Extract engine.
+
+## License
+
+Track Extract is released under the [MIT License](LICENSE).