redact: replace psarc/Rocksmith/official DLC references with neutral terms

Signed-off-by: barlind <tobias@barlind.se>

.claude/README.md

@@ -0,0 +1,42 @@
+# `.claude/` — Claude Code surfaces
+
+This directory holds [Claude Code](https://claude.ai/code) artifacts: skills, rules, and subagents. **Other AI tools** (Cursor, Copilot, Codex, Aider) should read [`AGENTS.md`](../AGENTS.md) instead — `.claude/` is Claude-Code-specific.
+
+## Layout
+
+```text
+.claude/
+├── agents/                            Subagents (invoked via @<name>)
+│   └── slopsmith-reviewer.md          Plugin-aware code review
+├── rules/                             Globs-scoped behaviour rules
+│   └── plugin-author.md               Rules that fire when editing plugins/**
+├── skills/                            Skills (description triggers auto-invocation)
+│   ├── plugin-scaffold/SKILL.md       Generate a new plugin skeleton
+│   ├── plugin-validate/SKILL.md       Validate a plugin.json against the schema
+│   └── speckit-*/                     Spec-kit skills (auto-generated; don't edit)
+├── settings.json                      Repo defaults (no hooks enabled by default)
+└── README.md                          You are here
+```
+
+## Conventions
+
+- **Spec-kit owns `skills/speckit-*`.** Don't edit those manually — they're regenerated by the spec-kit installer (`.specify/`).
+- **Repo skills live alongside spec-kit skills** in `skills/`. New skills should have a kebab-case directory name and a `SKILL.md` with YAML frontmatter.
+- **Hooks are off by default.** Hooks in `.claude/settings.json` run in every contributor's Claude Code session — enabling one imposes work on everyone. The settings file ships with `hooks: {}` and a commented example so anyone who wants to opt in can copy it locally.
+- **Subagent invocation.** Use `@slopsmith-reviewer` to invoke a subagent explicitly. Plain auto-routing isn't currently configured.
+
+## Adding a new skill
+
+1. Create `.claude/skills/<kebab-name>/SKILL.md`.
+2. YAML frontmatter must include `name` (must match directory) and `description` (must read like a sentence — Claude Code matches the description against user intent for auto-invocation).
+3. Body: instructions Claude follows when the skill triggers. Keep it concrete and short — long skills bit-rot.
+
+## Adding a new rule
+
+1. Create `.claude/rules/<topic>.md`.
+2. Frontmatter may include `globs:` (array of glob patterns scoping when the rule applies). Without `globs`, the rule loads for every session.
+3. Body: terse, imperative guidance — "always do X", "never do Y", "if you see Z, …".
+
+## Why so little here?
+
+The maintainer's personal Claude Code rules (context-mode routing, RTK, `@git-worker`, etc.) deliberately do **not** live in this repo. Those are user-global concerns in `~/.claude/` — keeping them out of the repo keeps the shared surface lean and makes the repo equally useful to contributors using Cursor, Copilot, plain editors, etc.

.claude/agents/slopsmith-reviewer.md

@@ -0,0 +1,68 @@
+---
+name: slopsmith-reviewer
+description: Plugin-aware code reviewer for Slopsmith. USE WHEN reviewing plugin changes, auditing a plugin against the manifest contract, checking that a plugin uses capability metadata / load_sibling / context["log"] correctly, or verifying that a `plugin.json` matches the schema and the directory it lives in. Returns a structured pass/fail report with specific file:line citations.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+# slopsmith-reviewer
+
+Plugin-aware reviewer for Slopsmith. Use when reviewing a plugin's code or manifest. Does **not** duplicate the built-in `peer-review` skill — focus is narrow: the plugin contract surface defined in [`docs/PLUGIN_AUTHORING.md`](../../docs/PLUGIN_AUTHORING.md) and enforced by [`schema/plugin.schema.json`](../../schema/plugin.schema.json), including `capability-pipelines.v1` metadata, and `tests/test_plugin_schema.py`.
+
+## When to invoke
+
+Use this agent when the user asks to:
+- "review this plugin"
+- "audit `plugins/<id>/`"
+- "check the manifest"
+- "verify the plugin uses load_sibling / logging correctly"
+- "lint plugin"
+
+Do **not** invoke for general code review — use the built-in `peer-review` skill for that.
+
+## Inputs
+
+The user typically points at a directory: `plugins/<id>/`. If no directory is given, ask which plugin to review.
+
+## Checklist (every review must run these)
+
+Run each item; structure the output as `PASS` / `FAIL` / `N/A` with file:line citations.
+
+1. **Manifest exists and validates.** `plugins/<id>/plugin.json` exists. Run:
+   ```bash
+   python -c "import json,jsonschema; s=json.load(open('schema/plugin.schema.json')); jsonschema.validate(json.load(open('plugins/<id>/plugin.json')), s); print('OK')"
+   ```
+2. **Manifest `id` matches the directory name.** `tests/test_plugin_schema.py::test_in_tree_manifest_id_matches_directory` enforces this — but call it out in review.
+3. **Declared plugin files exist.** For plugin-root-relative file fields (`script`, `routes`, `tour`, `settings.html`), `test -f plugins/<id>/<path>` must succeed.
+4. **License is on the curated allowlist** if present. Cross-check `plugin.json.license` against the SPDX list in [`CONTRIBUTING.md`](../../CONTRIBUTING.md) "Plugin licensing".
+5. **`type: "visualization"` ↔ `window.slopsmithViz_<id>` factory.** If `type == "visualization"`, grep `script` for the factory declaration.
+6. **Backend logging.** Grep `plugins/<id>/*.py` for `print(`, `traceback.print_exc(`, `logging.getLogger(`. Suggest `context["log"]` replacements.
+7. **Sibling imports.** If `routes.py` exists and grep finds bare `from <module> import` for any sibling Python file in the plugin dir, flag and recommend `context["load_sibling"]`.
+8. **Frontend IIFE.** If `script` exists, check the top of the file isn't running top-level statements that leak to global scope. Wrapping in `(function () { 'use strict'; ... })();` is the convention.
+9. **Capability-first frontend integration.** If the script wraps host globals or polls another plugin's globals, flag it as a capability gap unless the PR explicitly documents why no active domain can model the integration yet.
+10. **`localStorage` prefix.** Grep for `localStorage.` usage; keys must start with `<plugin_id>`.
+11. **Server-file allowlists are safe.** `settings.server_files` and `diagnostics.server_files` entries are relpaths under `context["config_dir"]`, not files under the plugin directory. Check for no leading `/`, no `..`, no backslashes, no `//`, no `./`, and no leading dotfiles. The schema enforces this but call it out.
+
+## Output format
+
+```text
+plugin-review: <plugin_id>
+=========================
+1. manifest validates                 PASS
+2. id matches directory               PASS
+3. declared plugin files exist        FAIL — script lists "missing.js" but plugins/<id>/missing.js is absent
+...
+
+Total: 10 PASS / 1 FAIL / 1 N/A
+Action items:
+- Remove the dangling script entry, or create the file.
+- Replace `print(...)` calls at routes.py:42, routes.py:88 with `context["log"].info(...)`.
+```
+
+If everything passes, say so explicitly — silent success is unhelpful in a review context.
+
+## Out of scope
+
+- General code style / formatting — use the built-in `peer-review`.
+- Bug-hunting beyond the plugin contract.
+- Suggesting major refactors. Stay on contract compliance.

.claude/rules/plugin-author.md

@@ -0,0 +1,49 @@
+---
+name: plugin-author
+description: Rules that apply when editing files under plugins/**. Enforces the plugin contracts documented in docs/PLUGIN_AUTHORING.md.
+globs:
+  - "plugins/**"
+---
+
+# Plugin authoring rules
+
+These rules apply only when editing files under `plugins/**`. They encode the contracts described in [`docs/PLUGIN_AUTHORING.md`](../../docs/PLUGIN_AUTHORING.md) so AI suggestions don't drift from them.
+
+## Manifest
+
+- **`plugin.json` is required** and must validate against [`schema/plugin.schema.json`](../../schema/plugin.schema.json). Required fields: `id`, `name`. The `id` must match the parent directory name (the loader keys discovery by directory; drift breaks plugin lookup).
+- **Plugins declare capability intent** with `standards: ["capability-pipelines.v1"]` and redaction-safe `capabilities` / `ui` metadata. Treat these declarations as the plugin's primary contract with Slopsmith.
+- **License must come from the curated allowlist** if the plugin is intended for the curated list. See [`CONTRIBUTING.md`](../../CONTRIBUTING.md) "Plugin licensing".
+- **`type: "visualization"`** requires a `script` field exporting `window.slopsmithViz_<id>`. See [`docs/plugin-visualization-contracts.md`](../../docs/plugin-visualization-contracts.md).
+
+## Backend (`routes.py`)
+
+- **Use `context["log"]`, never `print()` or `traceback.print_exc()`.** The CI workflow blocks `print(` and `traceback.print_exc(` in `server.py` / `lib/`; plugin code should follow the same rule. The provided logger is a stdlib `logging.Logger` namespaced to `slopsmith.plugin.<id>` with correlation IDs, JSON mode, and rotation already wired. See [`docs/plugin-logging.md`](../../docs/plugin-logging.md).
+- **Multi-file plugins must use `context["load_sibling"]("<module>")`**, not bare `from <module> import X`. Two plugins shipping a same-named helper collide via `sys.modules`. See [`docs/plugin-sibling-imports.md`](../../docs/plugin-sibling-imports.md).
+- **`setup(app, context)` is the required entry.** Don't run side effects at import time.
+
+## Frontend (`screen.js`)
+
+- **Wrap in an IIFE** — `(function () { 'use strict'; ... })();`. Frontend scripts share global scope; leaking variables collides with other plugins.
+- **Prefer capability commands, events, and provider APIs** for app coordination. Don't add new private global wrappers or cross-plugin polling; if the needed domain is missing, call that out as a capability gap.
+
+## State and config
+
+- **`localStorage` keys must be prefixed with the plugin id** to avoid collisions.
+- **`settings.server_files` declares config-dir paths the plugin wants to include in the Settings export/import flow.** Relpaths only — no `..`, no abs paths, no backslashes. See [`docs/plugin-manifest.md`](../../docs/plugin-manifest.md).
+- **`diagnostics.server_files` / `diagnostics.callable`** declares what enters the Export Diagnostics bundle. Keep payloads under 100 KB and don't include secrets. See [`docs/plugin-diagnostics.md`](../../docs/plugin-diagnostics.md).
+
+## Visualization specifics
+
+When `plugin.json` declares `"type": "visualization"`:
+
+- **Factory must be `window.slopsmithViz_<id>`** where `<id>` matches `plugin.json`.
+- **Factory must return a fresh object on each call** — splitscreen creates N instances.
+- **The renderer owns its `getContext()` call.** Declare `contextType: '2d'` or `'webgl2'` on the returned object so the highway can swap the canvas element when needed (`getContext` is one-shot per canvas).
+- **`draw(bundle)` receives difficulty-filtered arrays** — never read from `_filteredNotes` or other internals.
+
+See [`docs/plugin-visualization-contracts.md`](../../docs/plugin-visualization-contracts.md) for the full lifecycle and the Overlay + Note-state-provider contracts.
+
+## Testing
+
+When changing plugin internals, add or update a test under `tests/` (Python) or `tests/js/` (Node) or `tests/browser/` (Playwright). See [`docs/testing-plugins.md`](../../docs/testing-plugins.md) for fixtures (`isolate_logging`, `reset_plugin_state`).

.claude/settings.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "_comment": "Repo-default Claude Code settings for Slopsmith contributors. Hooks are intentionally empty by default — see commented example below.",
+
+  "hooks": {},
+
+  "_commented_example_hooks": {
+    "_comment": "Copy the block below into the empty `hooks` object above if you want plugin.json edits to be auto-validated against schema/plugin.schema.json, including capability metadata, on save. Per-user opt-in; not enabled by default because hooks run in every Claude Code session that loads this repo.",
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "command": "if echo \"$CLAUDE_TOOL_INPUT_FILE_PATH\" | grep -qE '^plugins/[^/]+/plugin\\.json$'; then python -c \"import json,sys,jsonschema; s=json.load(open('schema/plugin.schema.json')); m=json.load(open('$CLAUDE_TOOL_INPUT_FILE_PATH')); jsonschema.validate(m,s); print('OK','$CLAUDE_TOOL_INPUT_FILE_PATH')\"; fi"
+      }
+    ]
+  }
+}

.claude/skills/plugin-scaffold/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: plugin-scaffold
+description: Scaffold a Slopsmith plugin skeleton with capability-pipelines metadata. USE WHEN the user asks to create a new plugin, scaffold a plugin, bootstrap a plugin, new visualization plugin, new overlay plugin, new settings-only plugin, plugin starter, plugin skeleton. Args needed - plugin slug (snake_case) and type (visualization / overlay / settings-only / routes-only). Generates plugins/<id>/ with plugin.json, capability-pipelines metadata, screen.js, and optional routes.py / settings.html / Playwright test stub matching the requested type.
+---
+
+# plugin-scaffold
+
+Generates a minimum-viable Slopsmith plugin skeleton matching a requested shape. The output validates against [`schema/plugin.schema.json`](../../../schema/plugin.schema.json).
+
+## When to invoke
+
+The user says one of:
+- "scaffold a new plugin called X"
+- "create a visualization plugin"
+- "new overlay plugin"
+- "plugin starter for settings"
+- "bootstrap a routes-only plugin"
+
+If the plugin slug or type is missing, ask once.
+
+## Inputs
+
+| Arg | Required | Values | Notes |
+|---|---|---|---|
+| `id` | yes | snake_case | Becomes plugin's `id` field and directory name |
+| `name` | optional | string | Defaults to title-case of `id` |
+| `type` | yes | `visualization` / `overlay` / `settings-only` / `routes-only` | Determines which files get scaffolded |
+
+## What to generate
+
+**Common to all types:**
+
+- `plugins/<id>/plugin.json` — schema-valid manifest. Set `id`, `name`, `version: "0.1.0"`, `license: "AGPL-3.0-only"`, and `standards: ["capability-pipelines.v1", "plugin-runtime-idempotent.v1"]` by default.
+
+**`type=visualization`** — adds:
+- `"type": "visualization"` and `"script": "screen.js"` to manifest
+- `"capabilities": { "visualization": { "roles": ["provider"], "operations": ["renderer.create", "renderer.destroy", "renderer.inspect"], "mode": "active", "compatibility": "none", "ownership": "multi-provider", "safety": "safe", "version": 1 } }`
+- `screen.js` exporting `window.slopsmithViz_<id> = function () { return { contextType: '2d', init(canvas, bundle) { this.ctx = canvas.getContext('2d'); }, draw(bundle) { /* TODO */ }, destroy() {} }; };` plus a static `matchesArrangement` example commented out
+- `tests/browser/<id>.spec.ts` — Playwright stub that loads the app and asserts the plugin's factory is registered
+
+**`type=overlay`** — adds:
+- `"script": "screen.js"` to manifest (no `type` declared — overlays don't use the picker)
+- `"capabilities": { "ui.player-overlays": { "roles": ["provider"], "mode": "active", "compatibility": "none", "ownership": "multi-provider", "safety": "safe", "version": 1 } }`
+- a matching `"ui"` contribution with a stable overlay id and redaction-safe label
+- `screen.js` scaffolding an own-canvas + own-rAF loop for the declared overlay contribution, and respecting renderer ownership if it uses highway geometry helpers
+- `tests/browser/<id>.spec.ts` — toggle on / off test
+
+**`type=settings-only`** — adds:
+- `"settings": { "html": "settings.html" }` to manifest
+- `"settings_schema"` with a schema version and an empty `packable_keys` list
+- a `"ui"` settings contribution with a stable id
+- `settings.html` — empty form skeleton with explanatory comments
+- `screen.js` reading/writing `localStorage` keys prefixed with `<id>_`
+
+**`type=routes-only`** — adds:
+- `"routes": "routes.py"` to manifest
+- a conservative `"capabilities"` declaration for the route's Slopsmith-facing workflow; if the domain is unclear, ask what capability domain the route owns, provides, requests, or observes before finalizing the scaffold
+- `routes.py` with `def setup(app, context):` that registers one example route and uses `context["log"].info("plugin ready")` (never `print()`)
+- `tests/test_<id>_routes.py` — FastAPI TestClient stub
+
+## After scaffolding
+
+Run validation locally:
+
+```bash
+python -c "import json,jsonschema; s=json.load(open('schema/plugin.schema.json')); jsonschema.validate(json.load(open('plugins/<id>/plugin.json')), s); print('OK')"
+```
+
+Then point the user at [`docs/PLUGIN_AUTHORING.md`](../../../docs/PLUGIN_AUTHORING.md) and the relevant contract doc for the type they chose.
+
+## Don'ts
+
+- Don't invent plugin-local manifest conventions. If the user wants something custom, either express it through existing `capability-pipelines.v1` metadata or ask whether it should become a real schema field.
+- Don't scaffold a `requirements.txt` without confirming the deps. The plugin loader installs them on first load; an accidental dep slows everyone's startup.
+- Don't pre-fill `localStorage` keys without a prefix. Collisions across plugins are real.
+- Don't generate hidden side effects at import time (`screen.js` top level or `routes.py` top level). Keep all wiring inside the IIFE / `setup()`.
+
+## Verification
+
+The scaffolded plugin should pass:
+
+```bash
+pytest tests/test_plugin_schema.py::test_in_tree_manifest_validates -v
+pytest tests/test_plugin_schema.py::test_in_tree_manifest_id_matches_directory -v
+```

.claude/skills/plugin-validate/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: plugin-validate
+description: Validate a Slopsmith plugin's plugin.json against the schema and run structural checks. USE WHEN the user asks to validate a plugin, check the manifest, plugin.json errors, lint plugin, verify plugin structure, plugin license check, or audit plugin contract. Runs JSON Schema validation, capability metadata checks, file-existence checks for declared script/routes/settings.html/tour paths, and license-allowlist check.
+---
+
+# plugin-validate
+
+Runs the same checks `.github/workflows/validate-plugins.yml` + `tests/test_plugin_schema.py` run in CI, but **locally and instantly** — useful for catching errors before push.
+
+## When to invoke
+
+The user says one of:
+- "validate plugins/<id>"
+- "check the manifest for X"
+- "lint this plugin"
+- "verify my plugin.json"
+- "plugin license check"
+
+Works on either a specific plugin (e.g. `plugins/highway_3d/`) or all in-tree plugins if none is specified.
+
+## What to run
+
+```bash
+# All in-tree plugins (default)
+python <<'PY'
+import json, glob, sys, jsonschema, pathlib
+schema = json.load(open('schema/plugin.schema.json'))
+jsonschema.Draft202012Validator.check_schema(schema)
+ok = True
+for path in sorted(glob.glob('plugins/*/plugin.json')):
+    plugin_dir = pathlib.Path(path).parent
+    plugin_id = plugin_dir.name
+    m = json.load(open(path))
+    plugin_ok = True  # per-iteration flag so we don't print OK after a later FAIL
+    # 1. Schema, including capability-pipelines.v1 metadata
+    try:
+        jsonschema.validate(m, schema)
+    except jsonschema.ValidationError as e:
+        print(f"FAIL {path}: {e.message} (at {list(e.absolute_path)})")
+        ok = False
+        continue
+    # 2. id == directory name
+    if m['id'] != plugin_id:
+        print(f"FAIL {path}: id={m['id']!r} but directory is {plugin_id!r}")
+        ok = False
+        plugin_ok = False
+    # 3. Declared files exist
+    for field in ('script', 'routes', 'tour'):
+        if field in m and not (plugin_dir / m[field]).exists():
+            print(f"FAIL {path}: {field}={m[field]!r} but file missing")
+            ok = False
+            plugin_ok = False
+    if 'settings' in m and 'html' in m['settings']:
+        h = m['settings']['html']
+        if not (plugin_dir / h).exists():
+            print(f"FAIL {path}: settings.html={h!r} but file missing")
+            ok = False
+            plugin_ok = False
+    for field in ('settings', 'diagnostics'):
+        if field in m and 'server_files' in m[field]:
+            for relpath in m[field]['server_files']:
+                # server_files paths live under context["config_dir"], NOT the
+                # plugin dir, so we don't existence-check them here. We only
+                # confirm the path *looks* safe (already enforced by schema).
+                if '..' in relpath or relpath.startswith('/') or '\\' in relpath:
+                    print(f"FAIL {path}: {field}.server_files contains unsafe path {relpath!r}")
+                    ok = False
+                    plugin_ok = False
+    if plugin_ok:
+        print(f"OK   {path}")
+sys.exit(0 if ok else 1)
+PY
+```
+
+## Targeted invocation
+
+If the user names a specific plugin, swap the glob for `plugins/<id>/plugin.json` and report on just that one.
+
+## License-allowlist check
+
+If the user specifically asks for a license check (or the plugin declares `license` in `plugin.json`), additionally run:
+
+```bash
+pytest tests/test_plugin_schema.py::test_schema_license_enum_subset_of_contributing_allowlist -v --noconftest
+```
+
+(or skip `--noconftest` if `structlog` is installed locally).
+
+## Output
+
+Use the format from the script: `OK <path>` per validated manifest, `FAIL <path>: <reason>` per failure. Add a one-line summary:
+
+```text
+Result: 3/3 plugins valid (OK app_tour_library, app_tour_settings, highway_3d)
+```
+
+or
+
+```text
+Result: 2/3 plugins valid; 1 FAIL (see above)
+```
+
+## Related
+
+- [`schema/plugin.schema.json`](../../../schema/plugin.schema.json)
+- [`tests/test_plugin_schema.py`](../../../tests/test_plugin_schema.py)
+- [`.github/workflows/validate-plugins.yml`](../../../.github/workflows/validate-plugins.yml)
+- [`docs/plugin-manifest.md`](../../../docs/plugin-manifest.md)

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,85 @@
+name: Bug report
+description: Report something broken in Slopsmith core (server, frontend, library, player).
+title: "[bug] "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for reporting! Before submitting:
+        - For **plugin** issues, please open the issue in the plugin's own repository instead — plugins under `plugins/` are separate projects.
+        - For sensitive logs, redact paths/credentials. The `docs/diagnostics-bundle-spec.md` describes the redaction surface used by Export Diagnostics.
+
+  - type: input
+    id: version
+    attributes:
+      label: Slopsmith version
+      description: "Contents of the `VERSION` file at the root, or what the navbar badge shows."
+      placeholder: "e.g. 0.2.8"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: deployment
+    attributes:
+      label: How are you running Slopsmith?
+      options:
+        - Docker Compose (docker-compose.yml)
+        - Bare Python (python main.py)
+        - Proxmox CT (build-proxmox-ct.sh)
+        - slopsmith-desktop bundle
+        - Other (describe below)
+    validations:
+      required: true
+
+  - type: input
+    id: os
+    attributes:
+      label: Host OS / browser
+      placeholder: "e.g. macOS 15.4 + Chrome 134; Linux + Firefox 142"
+    validations:
+      required: true
+
+  - type: input
+    id: plugins
+    attributes:
+      label: Plugins enabled
+      description: "List the plugins active when the bug happened. Most bugs reproduce only with certain plugins."
+      placeholder: "highway_3d, fretboard, note_detect"
+
+  - type: textarea
+    id: repro
+    attributes:
+      label: Reproduction steps
+      description: "Numbered steps. Include song format (legacy archive / sloppak / loose) and arrangement type if relevant."
+      placeholder: |
+        1. ...
+        2. ...
+        3. ...
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected vs. actual behaviour
+    validations:
+      required: true
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs / diagnostics
+      description: |
+        Either paste relevant log lines (set `LOG_LEVEL=DEBUG` or `LOG_FORMAT=json` if useful) **or** attach an Export Diagnostics bundle. See `docs/diagnostics-bundle-spec.md` for what's inside the bundle and what's redacted.
+      render: text
+
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: Confirmations
+      options:
+        - label: I searched existing issues and didn't find a duplicate
+          required: true
+        - label: This is a core bug, not a plugin bug
+          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +1,11 @@
-blank_issues_enabled: true
+blank_issues_enabled: false
+contact_links:
+  - name: Plugin issues
+    url: https://github.com/slopsmith/slopsmith#plugins
+    about: Plugins live in their own repositories. Open plugin bugs/features in the plugin's own repo.
+  - name: Documentation questions
+    url: https://github.com/slopsmith/slopsmith/tree/main/docs
+    about: Plugin contracts, sloppak spec, diagnostics, and note-detect tuning are documented under docs/. Try there first.
+  - name: Security disclosures
+    url: https://github.com/slopsmith/slopsmith/security
+    about: For security issues, please use GitHub's private security advisory flow rather than a public issue.

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,57 @@
+name: Feature request
+description: Propose a feature, behaviour change, or new plugin contract.
+title: "[feature] "
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for the suggestion! For **plugin features**, open the issue in the plugin's own repository unless the change requires new core API.
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: What problem does this solve?
+      description: "Lead with the user/contributor pain — the solution shape often falls out of a sharp problem statement."
+    validations:
+      required: true
+
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposed solution
+      description: "What you'd like to see. UI mockups, code sketches, config examples all welcome."
+
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives considered
+
+  - type: dropdown
+    id: surface
+    attributes:
+      label: Which surface does this touch?
+      multiple: true
+      options:
+        - Server (FastAPI / lib/)
+        - Frontend (static/)
+        - Plugin contract (new field / event / API)
+        - Sloppak format
+        - WebSocket protocol
+        - Diagnostics
+        - Docs only
+        - Other (describe in proposal)
+
+  - type: textarea
+    id: plugin_impact
+    attributes:
+      label: Plugin author impact
+      description: "Does this require existing plugins to change? Add a new optional field? Break a contract? Be specific so the maintainer can size compatibility work."
+
+  - type: checkboxes
+    id: license
+    attributes:
+      label: License compatibility
+      options:
+        - label: If suggesting third-party code, it's AGPL-3.0-compatible (see CONTRIBUTING.md curated list)
+          required: true

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,38 @@
+<!--
+Thanks for the PR! A few quick reminders before you hit submit:
+- DCO sign-off on every commit (git commit -s; --amend -s to fix)
+- Plugin work? Check docs/PLUGIN_AUTHORING.md and validate plugin.json
+  against schema/plugin.schema.json, including capability metadata
+- Touching the highway / player UI? Add or update a Playwright test
+  under tests/browser/
+-->
+
+## Summary
+
+<!-- 1–3 bullets describing what changes and why. Link related discussion. -->
+
+## Linked issue
+
+<!-- Closes #1234, or "n/a" if this is a chore/docs change -->
+
+## Test plan
+
+<!-- How did you verify? Tick what applies. -->
+
+- [ ] `pytest -q` passes locally
+- [ ] `npm run test:js` passes locally
+- [ ] `npm test` (Playwright) passes locally — *or* CI will run it
+- [ ] Verified in `docker compose up` (live-reload working directory)
+- [ ] Plugin manifest validates against `schema/plugin.schema.json` (including capability metadata)
+- [ ] Not applicable — explain below
+
+## Screenshots / recordings
+
+<!-- For UI changes, paste before/after. Drag-drop into the editor or use a GIF. -->
+
+## Checklist
+
+- [ ] DCO sign-off on every commit (`Signed-off-by:` trailer)
+- [ ] Conventional-commit subject (`feat(scope):`, `fix(scope):`, `docs:`, `chore:`)
+- [ ] `CHANGELOG.md` `[Unreleased]` section updated
+- [ ] Documentation updated if behaviour or contracts changed

.github/copilot-instructions.md

@@ -0,0 +1,22 @@
+# GitHub Copilot instructions
+
+This file customizes GitHub Copilot Chat and Copilot inline suggestions for the Slopsmith repository.
+
+## Read first
+
+- [`AGENTS.md`](../AGENTS.md) — canonical project orientation (architecture, conventions, first-hour pitfalls, verification). This file is a thin pointer; the real content lives there.
+- [`docs/PLUGIN_AUTHORING.md`](../docs/PLUGIN_AUTHORING.md) — plugin work entry point
+
+## House rules
+
+- **License: AGPL-3.0-only.** Inbound contributions are AGPL-compatible. Do not suggest code copied verbatim from incompatible sources.
+- **DCO sign-off required** on every commit (`git commit -s`).
+- **No frontend frameworks.** Vanilla JS, Canvas, Tailwind classes. Do not suggest React/Vue/Svelte additions.
+- **Plugin backend logging.** Suggest `context["log"]`, never `print()`.
+- **Plugin Python imports.** For cross-file backend plugins, suggest `context["load_sibling"]("module_name")` instead of bare `from module_name import X`.
+- **Capability metadata.** For plugin integrations, suggest `standards: ["capability-pipelines.v1"]` and redaction-safe `capabilities` / `ui` metadata as the primary contract.
+- **DCO/license headers.** When creating a new file in the main repo, no license header is needed (the LICENSE file at root governs). Plugin authors should add an SPDX-License-Identifier comment to their plugin's source files; the `license` field in `plugin.json` must match the allowlist in [`CONTRIBUTING.md`](../CONTRIBUTING.md).
+
+## Validation
+
+When suggesting changes to a `plugin.json`, validate against [`schema/plugin.schema.json`](../schema/plugin.schema.json), including native `capability-pipelines.v1` metadata.

.github/workflows/ci.yml

@@ -39,7 +39,7 @@ jobs:
             first=$(printf '%s\n' "$hits" | head -n1)
             file=$(printf '%s' "$first" | cut -d: -f1)
             line=$(printf '%s' "$first" | cut -d: -f2)
-            echo "::error file=${file},line=${line}::print() or traceback.print_exc() found in server.py, lib/, or a bundled plugin routes.py. Use the feedBack logger (lib/logging_setup.py) — see issues #155 / #242."
+            echo "::error file=${file},line=${line}::print() or traceback.print_exc() found in server.py, lib/, or a bundled plugin routes.py. Use the slopsmith logger (lib/logging_setup.py) — see issues #155 / #242."
             exit 1
           fi
 
@@ -56,7 +56,7 @@ jobs:
 
   tailwind-fresh:
     # Guard that the committed static/tailwind.min.css is in sync with source.
-    # The Play CDN's runtime JIT was removed (feedBack-desktop#110); a prebuilt
+    # The Play CDN's runtime JIT was removed (slopsmith-desktop#110); a prebuilt
     # stylesheet only contains classes the scanner saw at build time, so stale
     # CSS silently ships unstyled elements. Rebuild and fail on any diff.
     name: tailwind-fresh

.github/workflows/sync-version.yml

@@ -1,9 +1,9 @@
 name: Sync VERSION from desktop release
 
-# Updates the VERSION file in this repo whenever feedBack-desktop
-# publishes a new tagged release. feedBack-desktop's build.yml
+# Updates the VERSION file in this repo whenever slopsmith-desktop
+# publishes a new tagged release. slopsmith-desktop's build.yml
 # dispatches the `desktop-released` event at the end of a successful
-# tag build (see docs in CLAUDE.md). A `workflow_dispatch` trigger is
+# tag build (see Versioning section in AGENTS.md). A `workflow_dispatch` trigger is
 # kept for manual testing / recovery.
 #
 # Related issue: #81.

.github/workflows/validate-plugins.yml

@@ -0,0 +1,82 @@
+name: Validate plugins
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'plugins/**/plugin.json'
+      - 'plugins/__init__.py'
+      - 'schema/plugin.schema.json'
+      - 'docs/plugin-manifest.schema.json'
+      - 'static/capabilities.js'
+      - 'CONTRIBUTING.md'
+      - 'requirements-test.txt'
+      - 'tests/test_plugin_schema.py'
+      - '.github/workflows/validate-plugins.yml'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'plugins/**/plugin.json'
+      - 'plugins/__init__.py'
+      - 'schema/plugin.schema.json'
+      - 'docs/plugin-manifest.schema.json'
+      - 'static/capabilities.js'
+      - 'CONTRIBUTING.md'
+      - 'requirements-test.txt'
+      - 'tests/test_plugin_schema.py'
+      - '.github/workflows/validate-plugins.yml'
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+          cache: 'pip'
+
+      - name: Install jsonschema
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements-test.txt
+
+      - name: Validate every in-tree plugin.json against capability schema
+        run: |
+          python - <<'PY'
+          import glob, json, sys
+          import jsonschema
+
+          schema_path = "schema/plugin.schema.json"
+          with open(schema_path) as f:
+              schema = json.load(f)
+
+          # Validate the schema itself is a well-formed JSON Schema.
+          jsonschema.Draft202012Validator.check_schema(schema)
+
+          manifests = sorted(glob.glob("plugins/*/plugin.json"))
+          if not manifests:
+              print("No plugin manifests found under plugins/*/plugin.json")
+              sys.exit(0)
+
+          failures = []
+          for path in manifests:
+              with open(path) as f:
+                  manifest = json.load(f)
+              try:
+                  jsonschema.validate(manifest, schema)
+                  print(f"OK   {path}")
+              except jsonschema.ValidationError as e:
+                  failures.append((path, e))
+                  print(f"FAIL {path}: {e.message} (at {list(e.absolute_path)})")
+          if failures:
+              sys.exit(1)
+          PY
+
+      - name: Run schema and capability contract tests
+        # --noconftest skips tests/conftest.py, which imports structlog
+        # (not in requirements-test.txt). The schema tests don't use
+        # shared fixtures, so this is safe and avoids dragging the full
+        # runtime requirements into a 2 KB schema-validation job.
+        run: pytest tests/test_plugin_schema.py -v --noconftest

.gitignore

@@ -9,7 +9,6 @@ build/
 .env*
 .DS_Store
 .vscode/
-data/web_library.db
 static/*.ogg
 static/*.mp3
 static/*.wav
@@ -21,15 +20,9 @@ plugins/*/
 # treats them identically to user-installed ones) but are bundled with
 # the default container image and marked `"bundled": true` in their
 # manifest. Add new core plugins as `!plugins/<id>/` exceptions.
-!plugins/achievements/
-!plugins/achievements/**
-plugins/achievements/__pycache__/
 !plugins/highway_3d/
 !plugins/highway_3d/**
 plugins/highway_3d/__pycache__/
-!plugins/folder_library/
-!plugins/folder_library/**
-plugins/folder_library/__pycache__/
 !plugins/app_tour_library/
 !plugins/app_tour_library/**
 !plugins/app_tour_settings/
@@ -42,8 +35,6 @@ plugins/minigames/__pycache__/
 !plugins/tuner/
 !plugins/tuner/**
 plugins/tuner/__pycache__/
-!plugins/input_setup/
-!plugins/input_setup/**
 node_modules/
 test-results/
 playwright-report/
@@ -55,4 +46,3 @@ Thumbs.db
 *.tmp
 *.swp
 .idea/
-plugins/support_creators

.specify/memory/constitution.md

@@ -1,19 +1,34 @@
-# FeedBack Constitution
+<!--
+Sync Impact Report
+Version change: 1.1.0 -> 1.2.0
+Modified principles:
+- III. Plugins Are the Extension Point — Isolated by `load_sibling` -> III. Plugins Are the Extension Point — Capability-Declared and Isolated
+Added sections: None
+Removed sections: None
+Templates requiring updates:
+- [updated] .specify/templates/plan-template.md — Constitution Check now names Slopsmith's concrete gates, including plugin capability declarations.
+- [reviewed] .specify/templates/spec-template.md — no structural update required; requirements remain feature-focused.
+- [reviewed] .specify/templates/tasks-template.md — no structural update required; the plan gate drives capability-related tasks.
+- [reviewed] .specify/templates/checklist-template.md — no structural update required.
+Follow-up TODOs: None
+-->
 
-> FeedBack is a self-hosted, single-user web app for browsing, playing, and
-> practicing interactive music notation, built around its own open `.sloppak`
+# Slopsmith Constitution
+
+> Slopsmith is a self-hosted, single-user web app for browsing, playing, and
+practicing interactive music notation, built around its own open `.sloppak`
 > chart format (charts imported from Guitar Pro / MusicXML or authored in the
 > built-in editor). This constitution captures the non-negotiable principles
 > that govern its core (`server.py`, `lib/`, `static/`) and that all in-tree
 > plugins (`plugins/<name>/`) inherit by default. It is a *retrospective*
 > document — the codebase came first, the principles below were distilled from
-> `CLAUDE.md`, `README.md`, and the shape of the existing implementation.
+> `AGENTS.md`, `README.md`, and the shape of the existing implementation.
 
 ## Core Principles
 
 ### I. Self-Hosted, Single-User, Docker-First
 
-FeedBack targets one user running one container against a personal
+Slopsmith targets one user running one container against a personal
 song library folder. There is no multi-tenant model, no
 authentication, no rate limiting, and no shared backend. Deployment is
 expressed as a single `docker compose up -d` against the bundled
@@ -41,12 +56,12 @@ is Tailwind CSS, served as a prebuilt static stylesheet
 (`static/tailwind.min.css`, regenerated by `scripts/build-tailwind.sh`)
 — never the runtime Play CDN, whose on-the-fly JIT rescans the DOM on
 the main thread and caused sustained frame drops with the 3D highway
-(feedBack-desktop#110). No React, Vue, Svelte, bundler, transpiler, or
+(slopsmith-desktop#110). No React, Vue, Svelte, bundler, transpiler, or
 TypeScript appears in the core static tree, and no build step runs on
 the serve path: the Tailwind build is a maintainer-only one-shot whose
 output is committed, so Docker / desktop / end users never build. New
 features extend `app.js` and the existing globals (`window.playSong`,
-`window.showScreen`, `window.createHighway`, `window.feedBack`).
+`window.showScreen`, `window.createHighway`, `window.slopsmith`).
 
 **Non-negotiable rules**
 
@@ -69,40 +84,55 @@ features extend `app.js` and the existing globals (`window.playSong`,
   layout invariants (`#player` flex-column, `#highway` flex:1,
   `#player-controls` at the bottom) MUST be preserved.
 
-### III. Plugins Are the Extension Point — Isolated by `load_sibling`
+### III. Plugins Are the Extension Point — Capability-Declared and Isolated
 
 Functionality that is not part of the irreducible "browse + play charts"
 loop ships as a plugin under `plugins/<name>/`, not as core code. Each
 plugin is its own directory (typically a separate git repo), discovered
 at startup via `plugin.json`, and free to add nav links, screens,
-settings panels, and `/api/plugins/<id>/...` routes. Plugins MUST
-isolate their backend Python imports via `context["load_sibling"]` so
-two plugins shipping a generic `extractor.py` / `util.py` / `client.py`
-do not collide in `sys.modules`.
+settings panels, and `/api/plugins/<id>/...` routes. Slopsmith-facing
+plugin behavior is capability-declared by default: manifests describe
+the domains a plugin owns, provides, requests, observes, validates, or
+contributes to before any runtime script hydrates. Runtime handlers,
+legacy wrappers, and private globals are implementation details or
+compatibility bridges, never the primary integration contract. Plugins
+MUST isolate their backend Python imports via `context["load_sibling"]`
+so two plugins shipping a generic `extractor.py` / `util.py` /
+`client.py` do not collide in `sys.modules`.
 
 **Non-negotiable rules**
 
 - Generic features (practice journal, setlist, metronome, tone player,
   tab view, MIDI control, stem mixing, editors, etc.) belong in a plugin
   repo, not in `lib/` or `server.py`.
+- Plugins with Slopsmith-facing behavior MUST declare
+  `standards: ["capability-pipelines.v1"]` plus redaction-safe
+  `capabilities`, `ui`, or `ui_contributions` metadata for the behavior
+  they expose. Metadata-only or transitional manifests that omit
+  capability participation MUST document why no current domain applies.
+- Runtime participants, event listeners, wrapper hooks, timers, DOM
+  roots, diagnostics contributors, and media nodes MUST be idempotent
+  across repeated script hydration. If a wrapper or private global is
+  still required, it MUST be documented as a compatibility bridge or a
+  missing capability-domain gap.
 - Plugin backend modules MUST use `context["load_sibling"]("name")` for
   sibling imports. Bare `import sibling` works during transition but
   triggers a startup warning when a name collides.
 - Plugins MUST register routes under `/api/plugins/<plugin_id>/...`,
-  use `window.feedBack.emit/on` for cross-plugin communication, and
-  prefix their `localStorage` keys with their plugin id.
+  use capability commands/events when an active domain exists, and
+  prefix their `localStorage` keys with their plugin id. General
+  `window.slopsmith.emit/on` events remain acceptable for host events or
+  domains that have not yet been promoted.
 - Plugins inherit this constitution and may layer additional rules in
   their own `CLAUDE.md`, but MUST NOT relax core principles (e.g. a
   plugin cannot require a frontend framework in core).
 
 ### IV. Backwards-Compatible Chart Library
 
-The whole point of FeedBack is that a user points it at an existing
+The whole point of Slopsmith is that a user points it at an existing
 song library folder and it Just Works. The library is scanned and
 indexed in `meta.db` (SQLite via `MetadataDB`). The open Sloppak
-format (`lib/sloppak.py`; specified at
-[got-feedback/feedback-feedpak-spec](https://github.com/got-feedback/feedback-feedpak-spec),
-published as feedpak — same format) is the preferred
+format (`lib/sloppak.py`, `docs/sloppak-spec.md`) is the preferred
 format and the home for new features; loose-folder XML charts
 (`lib/loosefolder.py`) are also discovered and played as a first-class
 format. Both must keep playing across releases.
@@ -145,7 +175,7 @@ push and PR to `main` against Python 3.12.
 All backend output goes through the stdlib `logging` pipeline configured
 by `lib/logging_setup.py`, controlled by `LOG_LEVEL` / `LOG_FORMAT` /
 `LOG_FILE`. Plugins receive a pre-configured `context["log"]` namespaced
-to `feedBack.plugin.<id>` and MUST use it instead of `print`. HTTP
+to `slopsmith.plugin.<id>` and MUST use it instead of `print`. HTTP
 responses carry a `X-Request-ID` header from `CorrelationIdMiddleware`
 and the same id appears as `request_id` in JSON log lines. The
 "Settings → Export Diagnostics" bundle (`lib/diagnostics_bundle.py`)
@@ -171,7 +201,7 @@ User configuration lives in two places: server-side under `CONFIG_DIR`
 (SQLite `meta.db`, `config.yaml`, plugin opted-in files) and client-
 side in browser `localStorage`. Both can be exported and re-imported
 as a single bundle (`POST /api/settings/import`,
-`GET /api/settings/export`, feedBack#113). Import is two-phase:
+`GET /api/settings/export`, slopsmith#113). Import is two-phase:
 phase-1 validates the entire bundle (schema, paths, encoding) and
 phase-2 commits each file atomically via temp+rename. Plugins opt
 their server-side files into the bundle via
@@ -188,7 +218,7 @@ no `..`, no absolute paths).
   Importing a bundle whose schema predates the running plugin's code
   MUST restore bytes verbatim — the plugin copes at next load.
 - The `VERSION` file is the single source of truth for the running
-  release; it is auto-bumped from `feedBack-desktop` releases via
+  release; it is auto-bumped from `slopsmith-desktop` releases via
   `.github/workflows/sync-version.yml`. Manual edits are reserved for
   out-of-band recovery only.
 
@@ -209,17 +239,18 @@ no `..`, no absolute paths).
   `flex:1`; `#player-controls` sits at the bottom. Hiding the highway
   collapses the layout — use `margin-top: auto` on controls if you
   need to hide it.
-- **Plugin load order**: alphabetical by directory name. The
-  `playSong` wrapper chain runs outermost-first (last-loaded wrapper
-  runs first). Plugins MUST tolerate dependent globals being absent
-  at load time and check at runtime
-  (`typeof window.X === 'function'`).
+- **Plugin load order**: alphabetical by directory name. Scripts MUST
+  tolerate dependent globals being absent at load time and check at
+  runtime (`typeof window.X === 'function'`). Load order and the
+  `playSong` wrapper chain are implementation details, not integration
+  contracts; plugins declare roles, ownership, compatibility, and UI
+  contributions through capability metadata.
 
 ## Development Workflow
 
 - **Branching**: never push directly to `main`. Always feature branch
   + PR. Exception: the automated `VERSION` bump from
-  `feedBack-desktop`'s release job, which commits to `main` as
+  `slopsmith-desktop`'s release job, which commits to `main` as
   `github-actions[bot]`.
 - **Reviews**: PRs run the local Codex review loop
   (`feedback_codex_preflight.md`) and the GitHub Copilot review pass
@@ -227,8 +258,9 @@ no `..`, no absolute paths).
   After pushing a fix, the CodeRabbit loop
   (`feedback_coderabbit_review.md`) runs to silence.
 - **Testing**: `pytest` for backend (`requirements-test.txt`),
-  Playwright for browser interactions (`tests/browser/`), CI runs both
-  on every push/PR to `main`.
+  Playwright for browser interactions (`tests/browser/`), and plugin
+  manifest schema validation for capability metadata. CI runs these on
+  every relevant push/PR to `main`.
 - **CHANGELOG**: every PR updates `[Unreleased]`. Releases rename
   `[Unreleased]` to `[X.Y.Z] - YYYY-MM-DD` (the VERSION bump itself is
   automated).
@@ -248,12 +280,13 @@ no `..`, no absolute paths).
   explicit constitutional amendment in this file.
 - Amendments require: (a) a PR that updates this file alongside the
   code change, (b) an entry in `CHANGELOG.md` under "Migration notes"
-  if user-visible, and (c) a corresponding update to `CLAUDE.md` so
-  AI agents and humans see the same source of truth.
+  if user-visible, and (c) a corresponding update to `AGENTS.md` and any
+  agent-specific imports or instructions so AI agents and humans see the
+  same source of truth.
 - The principles are listed in priority order. When two principles
   conflict (e.g. "vanilla frontend" vs. a plugin that wants to ship
   React), the lower-numbered principle wins by default; the
   higher-numbered principle's escape hatch is to live in a plugin
   with its own bundled assets.
 
-**Version**: 1.1.0 | **Ratified**: 2026-05-09 | **Last Amended**: 2026-06-01
+**Version**: 1.2.0 | **Ratified**: 2026-05-09 | **Last Amended**: 2026-06-03

.specify/templates/plan-template.md

@@ -31,7 +31,29 @@
 
 *GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.*
 
-[Gates determined based on constitution file]
+Answer each gate with PASS / FAIL / N/A and a short justification:
+
+- **Self-hosted Docker path**: Does the feature keep `DLC_DIR` and
+  `CONFIG_DIR` as the only required runtime inputs, with any new
+  dependency installable in the existing Docker image?
+- **Vanilla/source-served frontend**: Does core remain plain JS and
+  committed CSS, with no framework, runtime CDN/JIT, bundler, or
+  serve-path build step? If plugin CSS is needed, does it ship through
+  `styles`?
+- **Plugin and capability boundary**: If the feature is outside browse +
+  play custom DLC, is it plugin-shaped? Does every Slopsmith-facing plugin
+  behavior declare `capability-pipelines.v1` metadata (`capabilities`,
+  `ui`, or `ui_contributions`) and use `load_sibling` for backend
+  siblings?
+- **Song format compatibility**: Are legacy archive scanning, sloppak manifests,
+  arrangement IDs, and highway WebSocket messages kept backward-
+  compatible, or is a migration note planned?
+- **Pure/testable core**: Are new `lib/` helpers flat-importable,
+  side-effect-light, and covered where practical?
+- **Observability and diagnostics**: Does backend output use logging,
+  and do diagnostics remain redacted and versioned?
+- **Settings/versioning**: Are settings imports/export paths safe,
+  additive/idempotent, and compatible with the `VERSION` workflow?
 
 ## Project Structure
 

AGENTS.md

@@ -0,0 +1,179 @@
+# AGENTS.md
+
+Project orientation for AI coding assistants (Cursor, GitHub Copilot, OpenAI Codex, Aider, Claude Code, Cline, Continue, Cody, Devin, …) and human contributors.
+
+Slopsmith is a self-hosted web app for browsing, playing, and practicing interactive music notation, built around its own open `.sloppak` chart format. Charts come from importing Guitar Pro (GP5/GP8) or MusicXML, or from authoring in the built-in editor. It runs as a Docker container with a FastAPI backend (`server.py`), vanilla JavaScript frontend (`static/`), shared Python libraries (`lib/`), and an extensive plugin system (`plugins/`). No frontend frameworks — plain JS, HTML, Tailwind CSS. AGPL-3.0-only.
+
+This file is the canonical orientation. Tool-specific automation (Claude skills/subagents/rules, Copilot instructions, etc.) lives in [`.claude/`](.claude/) and [`.github/copilot-instructions.md`](.github/copilot-instructions.md); both point back here. For plugin work, start at [`docs/PLUGIN_AUTHORING.md`](docs/PLUGIN_AUTHORING.md).
+
+## Architecture quick reference
+
+```text
+server.py              FastAPI app — library API, WebSocket highway, plugin loading
+main.py                Programmatic uvicorn entrypoint — installs structlog before boot
+logging_setup.py       Structured logging + correlation IDs (LOG_LEVEL/LOG_FORMAT/LOG_FILE)
+static/
+  app.js               Main frontend — screens, library views, player, plugin loader
+  highway.js           Canvas note highway renderer (createHighway factory)
+  diagnostics.js       window.slopsmith.diagnostics namespace (loaded first in <head>)
+  index.html           Single-page app shell
+lib/
+  song.py              Core data models (Note, Chord, Arrangement, Song)
+  sloppak.py           Sloppak format support
+  sloppak_convert.py   Import conversion + Demucs stem split
+  loosefolder.py       Loose-folder XML chart support
+  audio.py             WEM/OGG/MP3 audio handling
+  retune.py            Pitch-shifting logic
+  tunings.py           Tuning name/offset utilities
+  gp2rs.py             Guitar Pro to arrangement XML conversion
+  gp2midi.py           Guitar Pro to MIDI
+plugins/
+  __init__.py          Plugin discovery, loading, requirements install, load_sibling
+  <plugin>/            Each plugin is its own directory (often a git submodule)
+schema/
+  plugin.schema.json   JSON Schema for plugin.json (validated in CI)
+docs/                  Plugin contracts + format specs (see Plugin authoring below)
+tests/                 pytest + tests/js/ (node --test) + tests/browser/ (Playwright)
+specs/                 Active spec-kit features (specs/001-slopsmith-platform/...)
+```
+
+## Running the app
+
+Canonical dev path is Docker Compose — `docker-compose.yml` live-mounts `static/`, `server.py`, `lib/`, `plugins/`, and `VERSION` into the container, so frontend edits are visible on refresh and backend edits trigger uvicorn auto-reload.
+
+```bash
+docker compose up                                     # build + run on :8000
+DLC_PATH=/path/to/dlc docker compose up               # override default Steam DLC path
+```
+
+For host-side runs (tests, scripts, no Docker), the programmatic entry point is `main.py`:
+
+```bash
+python main.py                                        # HOST=0.0.0.0 PORT=8000 default
+HOST=127.0.0.1 PORT=8001 python main.py
+```
+
+`main.py` installs the structlog pipeline via `logging_setup.configure_logging()` **before** uvicorn boots and passes `log_config=None` so uvicorn's `dictConfig` never overwrites it. Do not invoke `uvicorn server:app` directly during development — early lifecycle log lines will bypass the structured pipeline and correlation IDs.
+
+**Logging env vars** (read by `logging_setup`):
+- `LOG_LEVEL` — `DEBUG | INFO | WARNING | ERROR` (default `INFO`)
+- `LOG_FORMAT` — `json | text` (default `text` — coloured console)
+- `LOG_FILE` — optional path for a persistent log file (e.g. `/config/slopsmith.log`)
+
+Plugin backend code receives a pre-configured `context["log"]` logger namespaced to `slopsmith.plugin.<id>` — never use `print()`. See [`docs/plugin-logging.md`](docs/plugin-logging.md).
+
+## Testing
+
+```bash
+pytest                              # All Python tests
+pytest tests/test_plugins.py -v     # Specific file
+pytest -k "load_sibling" -v         # Pattern match
+
+npm run test:js                     # Node-native JS plugin-API contract tests (tests/js/)
+npm run install:playwright          # One-time: install Chromium for Playwright
+npm test                            # Playwright browser tests (tests/browser/)
+```
+
+Pytest config in `pyproject.toml` sets `pythonpath = [".", "lib"]` and `testpaths = ["tests"]`. CI runs `pytest` on every push/PR to `main` (Python 3.12). See [`docs/testing-plugins.md`](docs/testing-plugins.md) for fixtures (`isolate_logging`, `reset_plugin_state`) and Playwright patterns.
+
+## Git workflow
+
+- **Never push directly to `main`** — always create a feature branch and open a PR.
+- **DCO sign-off is mandatory.** `git commit -s` appends `Signed-off-by:`. Forgot? `git commit --amend -s`. See [`CONTRIBUTING.md`](CONTRIBUTING.md).
+- **Upstream remote** — set `upstream` to the canonical Slopsmith repository; `origin` is your fork.
+- **Plugins are gitlinks** — each plugin in `plugins/` is typically its own git repo (submodule or clone). Branch switches on the main repo can clobber plugin directories. Use `git update-index --assume-unchanged` for plugin dirs if needed.
+- **Commit style** — short imperative subject line, blank line, then body explaining *why*. Conventional-commit prefixes (`feat(scope):`, `fix(scope):`, `chore:`, `docs:`) are conventional in the log but not enforced.
+
+## Versioning
+
+- **`VERSION`** (repo root) — single source of truth; plain semver string. Bind-mounted into the container and copied by the Dockerfile so it's always available at `/app/VERSION`.
+- **`GET /api/version`** — returns `{"version", "source_url", "license_url"}`. `source_url` is overridable via `APP_SOURCE_URL` (default `https://github.com/byrongamatos/slopsmith`); `license_url` falls back to `source_url + "/blob/main/LICENSE"` and is overridable via `APP_LICENSE_URL`. Both must be `http(s)`; non-http(s) values are rejected.
+- **Auto-sync** — `.github/workflows/sync-version.yml` rewrites `VERSION` via a `repository_dispatch` (`desktop-released`) from `slopsmith-desktop`'s release job. As an explicit automation-only exception to "Never push directly to main", the sync job commits straight to `main` as `github-actions[bot]`. Humans still go through PRs.
+- **`CHANGELOG.md`** — [Keep a Changelog](https://keepachangelog.com/) format. Update `[Unreleased]` on each PR; release renames it.
+
+## Song formats
+
+Slopsmith supports two:
+
+- **Legacy archive** (encrypted, read-only) — fast metadata scan via `lib/sloppak.py`; full unpack for playback. Audio via `vgmstream-cli` + `ffmpeg`.
+- **Sloppak** (open format) — hand-editable, two interchangeable forms: `.sloppak` zip or `.sloppak/` directory. Preferred for new features. Full spec: [`docs/sloppak-spec.md`](docs/sloppak-spec.md). Key code: `lib/sloppak.py`, `lib/sloppak_convert.py`, `lib/song.py`.
+
+## Frontend conventions
+
+- **No frameworks** — vanilla JS, fetch API, DOM manipulation
+- **Plugin integration** — prefer documented capability domains, provider APIs, and redaction-safe UI contributions over private globals
+- **Storage** — `localStorage` for all user preferences, prefixed with plugin id
+- **Styling** — Tailwind utility classes; dark theme (`bg-dark-600`, `text-gray-300`, accent `#4080e0`, gold `#e8c040`)
+- **Naming** — camelCase for JS, kebab-case for CSS, snake_case for plugin IDs
+- **Player layout** — `#player` is `display:flex; flex-direction:column; position:fixed; inset:0`. `#highway` is `flex:1`. Hiding the highway collapses the layout — use `margin-top: auto` on controls if you must hide it.
+
+## Backend conventions
+
+- **Framework** — FastAPI + uvicorn (boot via `main.py`)
+- **Imports** — flat imports from `lib/` (no `__init__.py`): `from song import Song`
+- **Database** — SQLite via `MetadataDB` class with `threading.Lock`
+- **WebSocket** — JSON frames, try/except `WebSocketDisconnect`. Protocol: [`docs/websocket-protocol.md`](docs/websocket-protocol.md)
+- **Error handling** — graceful fallbacks (audio conversion errors don't crash the song; missing art returns a placeholder)
+- **Type hints** — used sparingly (`Path | None`, `dict`, `list`)
+- **Docstrings** — minimal; code is self-documenting
+
+## Plugin authoring — see [`docs/PLUGIN_AUTHORING.md`](docs/PLUGIN_AUTHORING.md)
+
+Plugins are the primary extension point. Each lives in `plugins/<name>/` with a `plugin.json` manifest that declares its `capability-pipelines.v1` participation. Curated plugins must be AGPL-3.0 or AGPL-compatible — see [`CONTRIBUTING.md`](CONTRIBUTING.md) for the allowlist. Manifest is validated in CI against [`schema/plugin.schema.json`](schema/plugin.schema.json), including capability metadata.
+
+Topic | Doc
+--- | ---
+Manifest reference (`plugin.json` fields) | [`docs/plugin-manifest.md`](docs/plugin-manifest.md)
+Capability declarations (`standards`, `capabilities`, `ui`) | [`docs/plugin-manifest.md#capabilities`](docs/plugin-manifest.md#capabilities)
+Visualization contracts | [`docs/plugin-visualization-contracts.md`](docs/plugin-visualization-contracts.md)
+Plugin styles (`styles: "assets/plugin.css"`) | [`docs/plugin-styles.md`](docs/plugin-styles.md)
+Backend `context["log"]` logging | [`docs/plugin-logging.md`](docs/plugin-logging.md)
+Diagnostics opt-in (export bundle) | [`docs/plugin-diagnostics.md`](docs/plugin-diagnostics.md)
+Multi-file backends (`load_sibling`) | [`docs/plugin-sibling-imports.md`](docs/plugin-sibling-imports.md)
+WebSocket highway protocol | [`docs/websocket-protocol.md`](docs/websocket-protocol.md)
+Testing plugins (pytest + Playwright) | [`docs/testing-plugins.md`](docs/testing-plugins.md)
+Diagnostics bundle layout | [`docs/diagnostics-bundle-spec.md`](docs/diagnostics-bundle-spec.md)
+Sloppak format spec | [`docs/sloppak-spec.md`](docs/sloppak-spec.md)
+Tuning the note_detect plugin | [`docs/note-detect-tuning.md`](docs/note-detect-tuning.md)
+
+## First-hour pitfalls (read these before your first PR)
+
+1. **`load_sibling` for cross-file backend plugins.** Bare `from extractor import X` in `routes.py` collides across plugins because Python caches by module name in `sys.modules`. Use `context["load_sibling"]("extractor")` — gets a per-plugin namespaced module. Full explanation: [`docs/plugin-sibling-imports.md`](docs/plugin-sibling-imports.md).
+
+2. **Capability declarations are the integration map.** Plugin behavior should be visible in `standards`, `capabilities`, and `ui` metadata before runtime code hydrates. If the domain you need is missing, document it as a capability gap instead of adding another private global contract.
+
+3. **Highway flex layout.** `#highway` has `flex:1` in the player. Hiding it with `display:none` removes the flex child and `#player-controls` floats to the top. If you must hide the highway, add `margin-top: auto` to the controls div.
+
+4. **Plugin gitlinks bite on branch switches.** Plugins are separate git repos cloned into `plugins/`. `git checkout` / `git clean` on the main repo can delete or clobber them. Use `git update-index --assume-unchanged plugins/<id>` if needed.
+
+5. **DCO sign-off is mandatory.** Every commit needs `Signed-off-by:`. Add via `git commit -s` (or `git commit --amend -s` if you forgot). PRs without DCO won't merge.
+
+## Verification (run before claiming done)
+
+```bash
+pytest -q                         # backend tests
+npm run test:js                   # JS plugin-API contract tests
+npm test                          # Playwright browser tests (slow; defers to CI)
+```
+
+If you touched `plugins/*/plugin.json` or `schema/`:
+
+```bash
+python -c "import json,glob,jsonschema; s=json.load(open('schema/plugin.schema.json')); [jsonschema.validate(json.load(open(p)), s) for p in sorted(glob.glob('plugins/*/plugin.json'))]"
+```
+
+## House rules
+
+- **AGPL-3.0-only.** Inbound contributions are inbound under the same terms. Don't paste from incompatible sources.
+- **DCO sign-off mandatory** on every commit (`git commit -s`).
+- **No frontend frameworks.** Vanilla JS, fetch API, Tailwind classes. Don't add React/Vue/Svelte.
+- **Backend logging.** Plugin `routes.py` must use `context["log"]`, never `print()`. See [`docs/plugin-logging.md`](docs/plugin-logging.md).
+- **Plugin Python imports.** Multi-file backends use `context["load_sibling"]("<module>")`, not bare `from <module> import`. See [`docs/plugin-sibling-imports.md`](docs/plugin-sibling-imports.md).
+- **Capability metadata.** Plugin integrations declare `standards: ["capability-pipelines.v1"]` plus redaction-safe `capabilities`/`ui` metadata as the primary integration contract.
+- **Spec-kit owns `.specify/` and `specs/`.** Don't modify those without explicit instruction; the `/speckit-*` skills own that surface.
+
+## Tool-specific surfaces (optional reading)
+
+- [`CLAUDE.md`](CLAUDE.md) — points back here. Exists for Claude Code's auto-loading convention. Claude-specific *automation* lives in [`.claude/`](.claude/) (skills, subagents, rules, settings).
+- [`.github/copilot-instructions.md`](.github/copilot-instructions.md) — points back here. Exists for GitHub Copilot's native instructions format.
+- No `.cursorrules` — Cursor reads `AGENTS.md` natively. Cursor-specific rules, if ever needed, would go under `.cursor/rules/`.

CHANGELOG.md

@@ -8,105 +8,69 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
-- **Playlists get content-dependent covers + custom art.** Playlist cards were a tiny `🎵` emoji on an empty square. Now a playlist's cover reflects its contents: **empty → the icon**, **a few songs → the first song's album art**, **4+ songs → a 2×2 art mosaic**. You can also **upload a custom cover** (a "Cover" button in the playlist detail view → image picker; "Remove cover" reverts to the content view). `MetadataDB.list_playlists()` now returns each playlist's first few song `art_urls`; `GET /api/playlists` and `GET /api/playlists/{id}` add `cover_url` when a custom cover exists. New routes `POST` / `GET` / `DELETE /api/playlists/{id}/cover` store a small PNG thumbnail under `CONFIG_DIR/playlist_covers/` (PIL-converted, like song-art upload); the cover is removed with the playlist. Frontend: `playlistCoverHtml(p)` in `static/v3/playlists.js`. Tests: `tests/test_playlists_api.py` (art_urls + cover roundtrip / reject-non-image / delete-cleanup), `tests/js/v3_playlist_cover.test.js`.
-- **v3 Songs: "Add to playlist" is now on each song's ⋮ "More" menu.** Previously a song could only be added to a playlist through select-mode (the checkbox → batch bar). The per-card overflow menu now has an **Add to playlist** row that targets that one song, reusing the same picker (choose a listed number or type a new name to create it). The select-mode batch flow and the single-song menu now share one extracted `addFilenamesToPlaylist(filenames)` helper in `static/v3/songs.js` (both grid and tree rows, since they share `openCardMenu`). Tests: `tests/js/v3_add_to_playlist_menu.test.js`.
-- **Resume where you left off — leaving a song now snapshots your place so an exit is recoverable, not a restart-from-zero.** Exiting the player (`showScreen()` teardown, before audio unload) writes `{song, arrangement, position, speed}` to `localStorage` (`feedBack.resumeSession`), and a non-blocking **"Resume practice"** pill offers it back on the next non-player screen (and on the next app launch). Clicking Resume re-enters the song, restores the arrangement + playback speed, and seeks to the saved position via the existing `_audioSeek` funnel; `playSong()` gains a `{ resume: {position, speed} }` option that arms a `song:ready`-consumed restore instead of the normal autostart, so the two never fight over playback. The snapshot is deliberately conservative — ignored for a song you barely started (< 3s) or had basically finished (within 5s of the end), cleared on natural song-end and once consumed, and expired after 24h. The pill is self-contained (inline-styled, body-appended, works identically in the classic and v3 shells with no Tailwind rebuild), never blocks, and a dismiss forgets the current snapshot for the session. This pairs with the Escape focus fix: now that Escape reliably leaves regardless of focus, an *accidental* exit is one tap to undo. Public surface: `window.resumeLastSession()` / `window.feedBack.resumeLastSession`. (The broader nav-state work — returning to a song after wandering into Settings → Tone Builder — is a separate, larger track; this lands the player-session slice.) Tests: `tests/browser/resume-session.spec.ts` (snapshot guards, staleness, pill show/hide/dismiss, resume consumption).
-- **Optional "Ask before leaving a song" confirm (Gameplay tab, default OFF).** A new client-only toggle (`confirmExitSong` in `localStorage`, in the v3 Gameplay settings + the Gameplay "Reset" set) for players who want a guard against an accidental exit. **Off by default — Escape leaves instantly, zero change for everyone else.** When on, a *user-initiated* exit (the player-scope Escape shortcut, or the player's ✕) opens a small true-modal confirm instead of leaving; auto-exit on song-end and a results screen's own Close are unaffected (they call `closeCurrentSong()` directly, which stays the unguarded actual-exit). The confirm honors the team's refined asks: **opening it pauses the song** (so it isn't running or being scored behind the prompt) and **Stay resumes exactly what was paused**; **Escape = Stay** — the dialog's capture-phase handler *dismisses* it (now consistent with every other modal and the generic `_confirmDialog`'s Esc=cancel), so a second Escape returns you to the (resumed) song rather than leaving; **Space/Enter (or click) Leave** by natively activating the default-focused "Leave" button ("just get me out"). Pause/resume run through the canonical `togglePlay()` path (HTML5 + `_juceMode`), guarded so a count-in, an already-paused song, or a teardown/seek/end behind the modal can't mis-resume. It's a real modal (`role="dialog" aria-modal="true"` / `.feedBack-modal`) with **Tab trapped inside it** and a **backdrop click that also Stays**, so the Escape/Space focus carve-outs treat it as a trap and don't fire player-back / play-pause behind it. The player Escape shortcut and the v3 ✕ route through a shared `window.requestExitSong()` gate (the ✕ also becomes origin-aware, matching Escape). Tests: `tests/browser/exit-confirm.spec.ts` (default-off instant exit, confirm-on opens + stays, second-Escape stays, backdrop stays, Stay/Leave, Enter-leaves); the audio pause/resume is verified manually on web + desktop (the mock song has no backing track).
-- **Folder Library — a bundled core plugin (`plugins/folder_library/`) that browses the DLC library by its on-disk folder tree.** Surfaces top-level folders → subfolders → songs (root-level songs land in `(Unsorted)`), with in-app folder management (create / rename / delete nested folders), song moves via dialog or drag-and-drop, and sort/filter that mirrors the host library's filter state. Wired into both the classic (v2) library toolbar and the v3 Songs page as a third **Folders** view alongside grid/tree; the plugin's `screen.js` is loaded once by the host and reused (idempotent IIFEs). Supersedes the former standalone "Folder Organizer" community plugin (removed from the README list). Backend (`routes.py`) registers `/api/plugins/folder_library/{tree,folder/create,folder/rename,folder/delete,song/move}`; **all filesystem mutations are confined to `DLC_DIR` and validated against path traversal** (per-segment name validation plus a resolved-containment check on `song/move`), and folder deletion relocates every song — de-duplicating colliding names — so a name clash never destroys a song. A two-level cache keeps re-opening folders fast. Tests: `tests/plugins/folder_library/test_routes.py` (path-safety helpers + move-traversal and delete-no-data-loss end-to-end).
-- **Full-screen (immersive) plugin screens — opt-in via `"fullscreen": true` in `plugin.json`.** DAW-style plugin UIs (e.g. a practice studio) need the whole viewport, not a scrolling content page below the topbar — embedded in the v3 shell they get cut off at the bottom with dead space up top. A plugin can now declare a top-level `"fullscreen": true`; `plugins/__init__.py` surfaces it as the `fullscreen` boolean on `/api/plugins` (mirroring the `settings_category` plumbing). When such a plugin's screen is active, `static/v3/shell.js` toggles `html.fb-immersive` from `syncActive()` (so it tracks every navigation incl. deep-link), and `static/v3/v3.css` hides the topbar, collapses the sidebar to a functional **icon rail** (kept reachable — Escape is bound only on player/settings scopes, so a fully-hidden sidebar would trap the user), and lets the active plugin screen fill `#v3-main`. Mirrors the existing `ss-follower-pre` chrome-hide pattern. Additive + opt-in: plugins without the flag are unaffected. Tests: `tests/test_plugins.py::test_fullscreen_flag_parsed_from_manifest`.
-- **Achievements wall sync — background drain worker (epic PR3, client side).** The bundled `achievements` plugin gains a dead-letter sync worker that POSTs queued Feat unlocks (and removals) to the hosted **feedback-achievements** wall service (separate repo). Idle unless a wall URL is configured (`FEEDBACK_ACHIEVEMENTS_WALL_URL`); uses `requests` with the baked-in client-token header, mirroring `lib/lyrics_transcribe`'s outbound pattern (explicit timeout, no raise on non-2xx). **Dead-letter, never drop** (pure `engine.drain_decision`): network error / `429` / `5xx` → keep `pending` (retry); other `4xx` → `dead_letter` (diagnosable, replayable); `2xx` → delete on server ack. A row leaves the queue only on ack or a user opt-out. `remove-me` now enqueues a wall removal keyed by the reused `player_hash`. Verified by an end-to-end staging round-trip (earn a Feat → drains onto the wall with name + short hash → `remove-me` → wall empties) with **no IP** in tables or access logs. Tests: `tests/plugins/achievements/test_sync.py` (decision table + ack/retry/dead-letter retention + four-field payload on the wire). The hosted service itself (FastAPI + SQLite-on-disk, Feats-only, hidden-until-first-global-unlock, profanity filter, in-memory rate limit, Render blueprint, migration tool) lives in the new `feedback-achievements` repo.
-- **Achievements wall — opt-in, privacy controls & data-minimization gate (epic PR2).** Sharing earned **Feats** on the (forthcoming) public wall is strictly opt-in. A new **onboarding step** (`static/v3/profile.js`, inserted after song-directory / before instrument paths — the wizard is now five steps) presents a plain-language card: it publishes only your display name and the Feats you earn, never songs/skills/scores, and is **off by default**. The bundled plugin's Settings panel (`plugins/achievements/settings.html`, mounted under the **System** tab via `settings.category`) carries the same toggle plus a **"Remove me from the wall"** button (`POST /api/plugins/achievements/remove-me` — wipes local synced state offline + enqueues a wall removal). Core adds `achievements_enabled` (bool, default `false`) to `_default_settings()` + the `/api/settings` validation block + `_RESETTABLE_SETTINGS_KEYS` in `server.py`, mirrored to `localStorage` in `app.js loadSettings()`. **Data-minimization contract (binding, code-enforced):** every outbound payload is built by a single explicit-dict serializer (`engine.build_wall_payload`, never `dict(row)`/`**model`) whose key-set is **exactly** `{display_name, player_hash, achievement_id, unlocked_at}` with `achievement_id` always a **Feat** id — a unit test asserts the four-field set and goes red on a fifth. Enqueue is doubly gated: it happens only when opted-in **and** a profile identity (name + the reused `player_hash`) exists; **competency unlocks never enqueue** (integration law). Tests: `tests/plugins/achievements/test_datamin.py` (key-set, opt-out/identity/competency gating) + `tests/test_settings_api.py` (flag persists/validates/resettable).
-- **Achievements & Feats of Power — local engine + tabbed Profile (epic PR1).** The Profile screen (`static/v3/profile.js`) becomes **tabbed** exactly like the v3 Settings page (`.fb-tabbar` / `.fb-tab[data-tab]` / `.fb-tabpanel[data-tab]`, active-tab persisted in `localStorage 'v3-profile-tab'`): a **Profile** (main) tab carrying the existing header + best-scores cards plus a new **Feats of Power** trophy shelf mount (`#v3-profile-feats-slot`, earned-only / hidden-until-earned), and an **Achievements** tab with a plugin mount (`#v3-profile-achievements-mount`) + `[data-empty-for]` empty note. Core dispatches a new **`v3:profile-rendered`** event after every render (mirrors `v3:settings-rendered`) so the plugin re-injects on each profile entry. A new bundled **`plugins/achievements/`** plugin owns the engine: SQLite under `<config_dir>/achievements/achievements.db` (`unlocks` / `counters` / `comp_ledger` / `sync_queue`), pure threshold/criterion math in the testable sibling `engine.py` (P-V), and routes under `/api/plugins/achievements/` (`activity`, `report-unlock`, `report-criterion`, `catalog`, `earned`, `feats`, `remove-me`). **Two surfaces, one engine, structurally separated (integration law):** **Feats** (activity/volume — Note Hunter, Marathon, Untouchable, Road Warrior, Time Served, Encore, two 🥚 secrets) read activity counters only, evaluated from a batched `song:ended` activity POST (notes only when **notedetect** is present — graceful degradation, no fake progress); **competency Achievements** (baseline: First Steps / Ascendant / Steady Hands / Renaissance + per-instrument Apprentice·Journeyman·Master / Personal Best / Challenger) are evaluated from **progression events only** and never re-derived from activity. The Achievements catalogue is always shown (locked = greyed), grouped by a secondary pill row over the **real progression paths** (Global / Guitar / Bass / Drums / Keys — auto-extends to new paths) with a per-category "X / Y earned" badge, defaulting to the player's primary path. Source plugins contribute their own competency defs and report unlocks through a versioned **`window.feedBack.achievements`** API (`register`/`registerAll`/`unlock`/`progress`), load-order-safe via the `window.__feedBackAchievementsPending` queue + an `achievements:ready` event (minigames pending-queue pattern); an absent source contributes nothing (no dead greyed rows). Opt-in publishing to a hosted Feats wall, the Settings privacy toggle, and the data-minimization gate land in epic PR2/PR3. Tests: `tests/plugins/achievements/test_engine.py` + `test_routes.py` (incl. the integration-law assertion that a competency unlock never reaches the Feats shelf).
-- **v3 settings page redesigned as a tabbed, card-row layout.** The single long scrolling settings screen becomes a horizontal tab bar (Gameplay / Audio / Graphics / Keybinds / Progression / Mic / Plugins / System) over card rows — each a leading icon + title + description with the control (toggle/dropdown/slider) on the right, plus a per-category "Reset" action. The markup lives in `static/v3/index.html` (so existing element ids keep hydrating through the unchanged `app.js` `loadSettings()`/`persistSetting()` path); a new `static/v3/settings.js` owns tab switching + active-tab persistence (`localStorage 'v3-settings-tab'`), the per-category reset, and a read-only **Keybinds** reference built from the live shortcut registry (`window.getAllShortcuts()`); styling is plain CSS in `static/v3/v3.css` (no Tailwind rebuild). **Plugins choose their settings tab** via a new optional `settings.category` field in `plugin.json` (`plugins/__init__.py` surfaces it as `settings_category`; `app.js` mounts each plugin's `<details>` panel into `#plugin-settings-<category>`, falling back to the generic Plugins tab) — `highway_3d` ships `category: "graphics"`; the out-of-repo notedetect/progression plugins should declare `"mic"` / `"progression"`. **New gameplay settings:** **Countdown before song** (a four-beat count-in before playback, wired end-to-end via the existing count-in engine + the song-start autostart path; key `countdown_before_song`, default off); **Miss penalty** (`miss_penalty`) and **Fail behavior** (`fail_behavior`) are persisted now but not yet consumed by scoring (shown with a "Not yet active" badge). "Note highway speed" surfaces the existing `master_difficulty` and stays in sync with the player-popover difficulty slider. New `POST /api/settings/reset` clears chosen keys back to defaults. Tests: `tests/test_settings_api.py` (new keys + reset), `tests/test_plugins.py::test_settings_category_parsed_from_manifest`, `tests/browser/settings-tabbed.spec.ts`.
-- **Full-mix audio exposed alongside stems for the stem mixer's auto-switch.** `lib/sloppak.py::load_song` now parses the optional manifest `original_audio:` key (the single pre-separation mixdown, e.g. `original/full.ogg`) into a new `LoadedSloppak.original_audio` field, with the same path-traversal guard and permissive "missing → disabled" posture as the `drum_tab` loader. The highway WS `song_info` frame additively carries three new fields next to `stems`: `original_audio_url` (served by the existing `/api/sloppak/{filename}/file/{rel_path}` endpoint, `None` when the pack ships stems only), `has_original_audio`, and `has_stems` (mirroring the `has_drum_tab`/`has_keys` flag convention). The stems plugin consumes `original_audio_url` to play the untouched single file while every stem slider is at unity and switch to the separate stems the moment one drops below 100%. **Migration notes:** the `song_info` message shape is a stable contract — these are purely additive; all existing fields are unchanged. `audio_url` still points at stem[0] when stems exist (it is only the degraded native fallback); the one behavioural change is that a stem-less, full-mix-only sloppak now sets `audio_url` to the full mix instead of emitting `audio_error`, so it plays natively.
-- **Autoplay & auto-exit — a global "click it, it plays; finish, you're back at the menu" option (default ON).** New single Settings toggle (`autoplayExit` in `localStorage`, surfaced in both the v3 and classic settings screens; absence of the key = enabled) that closes the friction at both ends of the play loop. **Autoplay:** `playSong()` previously loaded a chart paused, requiring a Play press; a one-shot flag armed per fresh load is now consumed by the next `song:ready` (highway.js) to auto-start via the existing `togglePlay()` path (HTML5 + `_juceMode` + count-in). Arrangement switches / seeks reuse the same `song:ready` event but never arm the flag, so they don't auto-restart. **Auto-exit:** on `song:ended`, core returns to the launching menu after a short grace delay — unless a visible full-screen results/dialog overlay is on top (detected via `[role=dialog][aria-modal]` / `.fixed.inset-0` with a `getClientRects()` visibility test that works for `position:fixed`), in which case the return is deferred so that score screen's own Close button (calling `window.closeCurrentSong()`) drives the exit. A plugin can also defer explicitly via the new `window.feedBack.holdAutoExit()` (called synchronously from its own `song:ended` handler — core's listener runs first). Both paths mean **no external plugin PR is required** for a results screen to be respected. **Context-aware destination:** the player's remembered origin (`_playerOriginScreen`) now honours any real launch screen instead of clamping to library/home/favorites, and a one-shot `window.feedBack.setReturnScreen(id)` override lets the lessons catalog (`static/v3/lessons.js`) send a finished lesson back to the lessons screen — not the song library — even though the external tutorials plugin owns the `playSong` call. Also exposes a read-only `window.feedBack.autoplayExit` getter for plugins. Songs and lessons share the same `playSong` → highway path, so both inherit the behaviour. Core-only (`static/app.js`, `static/v3/lessons.js`, both `index.html`s); the end-of-song score screen itself remains a plugin. Optional polish (not required — the overlay heuristic already covers it): external scoring/note-detection plugins (e.g. SlopScale) may call `holdAutoExit()` + `closeCurrentSong()` for an exact, heuristic-free handoff.
-- **"Song Editor" promoted to a first-class v3 sidebar item.** The editor
-  plugin (`id: editor`) now gets its own dedicated sidebar entry — under the
-  Library group, just below Songs — via the existing `PROMOTED_PLUGINS`
-  mechanism in `static/v3/shell.js`, instead of being reachable only through
-  the generic Plugins gallery. Gated on the plugin actually being installed
-  (`renderPromotedNav` checks `/api/plugins`), so it appears only when the
-  editor is loaded. The displayed label comes from the plugin's manifest
-  `nav.label`.
-- **Guitar Pro → notation importer (`lib/gp2notation.py`)** (feedBack#825 WS4b, epic #828). Piano/keys tracks imported from Guitar Pro (GPIF: `.gpx` GP6 / `.gp` GP7-8) now produce real Sloppak Notation Format data (sloppak-spec §5.3) alongside the `midi = string*24 + fret` guitar wire encoding. `gp2rs_gpx.convert_file` writes a `<stem>.notation.json` sidecar next to each keys arrangement XML (best-effort — a notation bug never breaks the RS-XML conversion), and `gp2notation.attach_notation_to_sloppak()` is the assembly-side helper that renames it into `notation_<id>.json` + adds the per-arrangement `notation:` manifest sub-key. Voice→staff routing salvages the logic from PR #703 (whose `stf` wire-field approach this supersedes): GP voice position 0 → `rh` staff (`G2`), positions ≥ 1 → `lh` (`F4`); a forced-LH track (the merged `Piano LH` partner from `_find_piano_pairs`, or a standalone track named `… LH`) routes everything to `lh` — preserving authored hand crossings instead of inferring hands from pitch. Emits measures with absolute `t` from the bar-indexed tempo map, change-only `ts`/`tempo`/`ks`, and `beat_groups` for compound/irregular meters (6/8 → `[3,3]`, 9/8 → `[3,3,3]`, 5/8 → `[2,3]`, 7/8 → `[2,2,3]` — cf. the feedBack#261 denominator pitfalls); beats carry `dur`/`dot`/`tu`/`rest` from GP rhythms and notes carry absolute `midi` (String+Fret resolves via the string template's concert pitches, Tone+Octave via `(octave+1)*12 + step`) with `tied` continuations kept as real beats (engraving needs the tied notehead — unlike the RS-XML walk, which drops them and extends sustain). Timing reuses the `gp2rs_gpx` machinery (bar-indexed tempo map, per-beat rhythm durations, `_note_midi`) so notation lines up with the RS XML the highway plays — with one deliberate divergence: double dots advance time ×1.75 (vs. the RS-XML walk's single-dot ×1.5 approximation) so a written `dot: 2` agrees with the emitted beat times; sharing the walk itself stays tracked in feedBack#618. Tests: `tests/test_gp2notation.py`.
-- **Legacy keys → notation lifter (`scripts/lift_keys_notation.py`)** (feedBack#825 WS4c, epic #828). One-time batch converter that lifts existing **directory-form** piano/keys sloppaks from the legacy guitar wire encoding (`midi = s*24 + f`) into real Sloppak Notation Format files (sloppak-spec §5.3). Candidates are arrangements whose name matches `\b(keys|piano|keyboard|synth)\b` (case-insensitive); each gets a `notation_<id>.json` plus the per-arrangement `notation:` manifest sub-key. Measures derive from the song-level `beats` downbeats (`measure >= 0`; `song_timeline.json` preferred, first-arrangement fallback), with per-measure tempo from downbeat spacing (emitted only on a > 1 BPM change). Durations come from the wire sustain (`sus`, legacy `l` alias) when present, else the gap to the next onset in the same hand — quantized to the nearest plain/single-dotted `{1,2,4,8,16,32}` denominator at the local tempo, floored at a 32nd. Hands are split heuristically: onsets within 10 ms form a group; a group spanning > 12 semitones splits at its largest internal interval gap (low side → `lh`), otherwise the whole group goes by mean pitch vs middle C — single-staff output when everything lands on one hand. Idempotent (arrangements already carrying `notation:` are skipped; an orphan `notation_<id>.json` without the manifest key is refused, not overwritten) with `--dry-run` support; every payload is checked via `notation.validate_notation` before write. Honest caveat: the manifest is round-tripped through PyYAML (`safe_load` + `safe_dump(sort_keys=False)`) — key order survives, YAML comments/custom formatting do not (the script warns when comments are present). Zip-form `.sloppak` files are reported and skipped. Tests: `tests/test_lift_keys_notation.py`.
-- **Notation schema v1 freeze — completeness batch** (feedBack#822, epic #828). Adds the low-hanging-fruit fields ahead of content production: top-level credits `rights`/`lyricist`/`arranger`; measure `pickup` (anacrusis); beat `arp` (arpeggiate), `ferm` (fermata), and **typed grace notes** — `grace: "a"` (acciaccatura, MusicXML `grace/@slash=yes`) / `"p"` (appoggiatura); note `stem` (`"up"`/`"down"` force). Pedal is settled as the existing `spd`/`sph`/`spu` trio with a documented MusicXML `<pedal start|change|stop>` mapping — no separate `ped` field. A new "v1 non-features" spec subsection pins the accepted limitations (microtonal, figured bass, mid-measure key/time/clef changes, `ott`/`barline`/ornaments/`trem`/`glis`) as additive-v1.x territory. `lib/notation.py` gains the `GRACE_TYPES`, `STEM_DIRECTIONS`, and `DYNAMICS` vocabularies; the validator stays permissive by design.
-- **Notation format — standard musical notation as a first-class sloppak type.** Promotes keys, piano, violin, and any other staff-notation instrument out of the guitar wire format and into their own data structure, following the same promotion path used for drums (feedBack#344). New `lib/notation.py` defines the canonical vocabulary (`CLEFS`, `DURATIONS`, `SCHEMA_VERSION`), a permissive `validate_notation()` check, and `measures_to_wire()` / `measure_to_wire()` wire helpers. `lib/sloppak.py::load_song` reads a new per-arrangement `notation:` sub-key from each arrangement entry in the manifest (Option B: per-arrangement, not song-wide), applies path-traversal guards, validates the parsed JSON via `validate_notation()`, and surfaces all notation payloads on `LoadedSloppak.notation_by_id` (a `dict[str, dict]` keyed by arrangement id). A failed or missing notation file for one arrangement does not abort or skip the arrangement itself — partial-failure isolation mirrors the drum tab loader. `file:` is now optional when `notation:` is present: the loader creates a minimal stub arrangement so a notation-only arrangement entry does not require a guitar wire format JSON. `/ws/highway/{filename}` gains two new message types — `notation_info` (staves, instrument, total measure count) and chunked `notation_measures` (32 measures per chunk) — streamed after `sections` and before `anchors`; `song_info` carries a new `has_notation: bool` flag so viz pickers can auto-activate the notation plugin regardless of arrangement name. The notation file schema is measure-structured (`measure → staff → voice → beat → note`), uses MIDI for pitch (no string/fret/tuning indirection), and carries the full set of effects that alphaTab can render. See `docs/sloppak-spec.md` §5.3 for the full schema. Open questions resolved per the piano/keys epic (feedBack#828 / #822): Option B (per-arrangement `notation:` sub-key) and `file:`-optional-when-`notation:`-present are the endorsed design.
+- **Guitar Pro → notation importer (`lib/gp2notation.py`)** (slopsmith#825 WS4b, epic #828). Piano/keys tracks imported from Guitar Pro (GPIF: `.gpx` GP6 / `.gp` GP7-8) now produce real Sloppak Notation Format data (sloppak-spec §5.3) alongside the `midi = string*24 + fret` guitar wire encoding. `gp2rs_gpx.convert_file` writes a `<stem>.notation.json` sidecar next to each keys arrangement XML (best-effort — a notation bug never breaks the RS-XML conversion), and `gp2notation.attach_notation_to_sloppak()` is the assembly-side helper that renames it into `notation_<id>.json` + adds the per-arrangement `notation:` manifest sub-key. Voice→staff routing salvages the logic from PR #703 (whose `stf` wire-field approach this supersedes): GP voice position 0 → `rh` staff (`G2`), positions ≥ 1 → `lh` (`F4`); a forced-LH track (the merged `Piano LH` partner from `_find_piano_pairs`, or a standalone track named `… LH`) routes everything to `lh` — preserving authored hand crossings instead of inferring hands from pitch. Emits measures with absolute `t` from the bar-indexed tempo map, change-only `ts`/`tempo`/`ks`, and `beat_groups` for compound/irregular meters (6/8 → `[3,3]`, 9/8 → `[3,3,3]`, 5/8 → `[2,3]`, 7/8 → `[2,2,3]` — cf. the slopsmith#261 denominator pitfalls); beats carry `dur`/`dot`/`tu`/`rest` from GP rhythms and notes carry absolute `midi` (String+Fret resolves via the string template's concert pitches, Tone+Octave via `(octave+1)*12 + step`) with `tied` continuations kept as real beats (engraving needs the tied notehead — unlike the RS-XML walk, which drops them and extends sustain). Timing reuses the `gp2rs_gpx` machinery (bar-indexed tempo map, per-beat rhythm durations, `_note_midi`) so notation lines up with the RS XML the highway plays — with one deliberate divergence: double dots advance time ×1.75 (vs. the RS-XML walk's single-dot ×1.5 approximation) so a written `dot: 2` agrees with the emitted beat times; sharing the walk itself stays tracked in slopsmith#618. Tests: `tests/test_gp2notation.py`.
+- **Legacy keys → notation lifter (`scripts/lift_keys_notation.py`)** (slopsmith#825 WS4c, epic #828). One-time batch converter that lifts existing **directory-form** piano/keys sloppaks from the legacy guitar wire encoding (`midi = s*24 + f`) into real Sloppak Notation Format files (sloppak-spec §5.3). Candidates are arrangements whose name matches `\b(keys|piano|keyboard|synth)\b` (case-insensitive); each gets a `notation_<id>.json` plus the per-arrangement `notation:` manifest sub-key. Measures derive from the song-level `beats` downbeats (`measure >= 0`; `song_timeline.json` preferred, first-arrangement fallback), with per-measure tempo from downbeat spacing (emitted only on a > 1 BPM change). Durations come from the wire sustain (`sus`, legacy `l` alias) when present, else the gap to the next onset in the same hand — quantized to the nearest plain/single-dotted `{1,2,4,8,16,32}` denominator at the local tempo, floored at a 32nd. Hands are split heuristically: onsets within 10 ms form a group; a group spanning > 12 semitones splits at its largest internal interval gap (low side → `lh`), otherwise the whole group goes by mean pitch vs middle C — single-staff output when everything lands on one hand. Idempotent (arrangements already carrying `notation:` are skipped; an orphan `notation_<id>.json` without the manifest key is refused, not overwritten) with `--dry-run` support; every payload is checked via `notation.validate_notation` before write. Honest caveat: the manifest is round-tripped through PyYAML (`safe_load` + `safe_dump(sort_keys=False)`) — key order survives, YAML comments/custom formatting do not (the script warns when comments are present). Zip-form `.sloppak` files are reported and skipped. Tests: `tests/test_lift_keys_notation.py`.
+- **Notation schema v1 freeze — completeness batch** (slopsmith#822, epic #828). Adds the low-hanging-fruit fields ahead of content production: top-level credits `rights`/`lyricist`/`arranger`; measure `pickup` (anacrusis); beat `arp` (arpeggiate), `ferm` (fermata), and **typed grace notes** — `grace: "a"` (acciaccatura, MusicXML `grace/@slash=yes`) / `"p"` (appoggiatura); note `stem` (`"up"`/`"down"` force). Pedal is settled as the existing `spd`/`sph`/`spu` trio with a documented MusicXML `<pedal start|change|stop>` mapping — no separate `ped` field. A new "v1 non-features" spec subsection pins the accepted limitations (microtonal, figured bass, mid-measure key/time/clef changes, `ott`/`barline`/ornaments/`trem`/`glis`) as additive-v1.x territory. `lib/notation.py` gains the `GRACE_TYPES`, `STEM_DIRECTIONS`, and `DYNAMICS` vocabularies; the validator stays permissive by design.
+- **Notation format — standard musical notation as a first-class sloppak type.** Promotes keys, piano, violin, and any other staff-notation instrument out of the guitar wire format and into their own data structure, following the same promotion path used for drums (slopsmith#344). New `lib/notation.py` defines the canonical vocabulary (`CLEFS`, `DURATIONS`, `SCHEMA_VERSION`), a permissive `validate_notation()` check, and `measures_to_wire()` / `measure_to_wire()` wire helpers. `lib/sloppak.py::load_song` reads a new per-arrangement `notation:` sub-key from each arrangement entry in the manifest (Option B: per-arrangement, not song-wide), applies path-traversal guards, validates the parsed JSON via `validate_notation()`, and surfaces all notation payloads on `LoadedSloppak.notation_by_id` (a `dict[str, dict]` keyed by arrangement id). A failed or missing notation file for one arrangement does not abort or skip the arrangement itself — partial-failure isolation mirrors the drum tab loader. `file:` is now optional when `notation:` is present: the loader creates a minimal stub arrangement so a notation-only arrangement entry does not require a guitar wire format JSON. `/ws/highway/{filename}` gains two new message types — `notation_info` (staves, instrument, total measure count) and chunked `notation_measures` (32 measures per chunk) — streamed after `sections` and before `anchors`; `song_info` carries a new `has_notation: bool` flag so viz pickers can auto-activate the notation plugin regardless of arrangement name. The notation file schema is measure-structured (`measure → staff → voice → beat → note`), uses MIDI for pitch (no string/fret/tuning indirection), and carries the full set of effects that alphaTab can render. See `docs/sloppak-spec.md` §5.3 for the full schema. Open questions resolved per the piano/keys epic (slopsmith#828 / #822): Option B (per-arrangement `notation:` sub-key) and `file:`-optional-when-`notation:`-present are the endorsed design.
 - **`song_timeline.json` — beats and sections as a top-level file.** A new optional top-level file pointed at by a new manifest key (`song_timeline: song_timeline.json`) provides the correct home for song-wide beats and sections, replacing the legacy convention of embedding them in the first arrangement JSON. The loader in `lib/sloppak.py` reads and validates the file (must be a dict with `beats` and `sections` as lists), clears and repopulates `Song.beats` / `Song.sections` from it when present, and stores the raw dict on `LoadedSloppak.song_timeline`. The existing arrangement-JSON fallback is fully preserved: all existing sloppaks that omit `song_timeline:` continue to load without any change. This is a prerequisite for notation-only sloppaks, which may have no arrangement JSON at all and therefore no carrier for beats/sections data. New sloppaks should put beats/sections in `song_timeline.json` only. See `docs/sloppak-spec.md` §2 and §5.3.
-- **`note-detection` capability domain promoted — control plane (spec 009)** (feedBack#727/#728, epic #828). New core host `static/capabilities/note-detection.js`: provider registry (kinds `midi`/`engine`/`js`, primitives `pitch.estimate`/`verify.target`), requester-owned context-scoped detection bindings (`open-binding`/`close-binding`/`set-target`/`clear-target` — each binding carries its own redacted tuning context, independent of the host's loaded song, per spec-009 FR-003), and hit/miss/verdict observability events (consumers own judgment). The legacy chart-coupled `highway.setNoteStateProvider` surface keeps working and is wrapped for compatibility-shim hit accounting. Diagnostics (`feedBack.note_detection_capability.v1`) carry provider/binding summaries and bounded outcomes — no raw audio, device labels, or song identity. Migrating the chart path, Step Mode verify, minigames YIN, and the engine verifier onto bindings is the remainder of the spec-009 slice.
-- **`visualization` capability domain promoted (cap:6)** (feedBack#828). New core host `static/capabilities/visualization.js` registers a provider-coordinator owning the highway renderer surface: commands `inspect` / `list-providers` / `select-renderer` / `clear-renderer` (selection delegates to the existing picker so persistence, WebGL2 gating, and fallback stay single-sourced), events `providers-refreshed` / `renderer-changed` / `renderer-ready` / `renderer-failed`. Legacy discovery (`type: "visualization"` manifests, `window.feedBackViz_*` globals) keeps working unchanged and is accounted as compatibility shims with hit counts. `static/app.js` attributes every renderer change (auto-match / user-select / fallback) and auto-match outcomes into the domain. Diagnostics (`feedBack.visualization_capability.v1`) carry provider ids/labels/context types, active renderer + selection source, last auto-match outcome, and last failure — no song filenames/titles. Per-panel (splitscreen) selection is a tracked follow-up.
-- **Viz picker routes notation arrangements** (feedBack#826, epic #828). `window.feedBack.currentSong` gains `hasNotation` (sibling of `hasDrumTab`) from the `song_info` frame's `has_notation` flag, so notation viz plugins (Staff View, Keys Highway 3D) can gate `matchesArrangement` on data presence instead of arrangement-name heuristics. When a notation-only arrangement (no wire notes — `file:` omitted per sloppak-spec §5.3) falls through Auto with no notation plugin installed, the built-in highway still takes the canvas but the Auto label reads "no notation view installed" and a one-shot dismissable hint points at the visualization picker — never a silently blank board.
-- **Keys instrument path in progression** (feedBack#828). New `data/progression/paths/keys.json` (5 levels / 15 challenges at parity with the guitar path) plus keys-flavoured daily/weekly quest pool entries (`d.keys-one` "Ivory Tower", `w.keys-three` "Grand Recital"). `lib/progression.py::instrument_for_arrangement()` now attributes `type: piano|keys` arrangements — and names matching `keys`/`piano`/`keyboard`/`synth` on a word boundary — to the new `keys` instrument, so scored keys runs advance the path automatically. Purely content + attribution: no schema or API changes.
-- **v3 library: exact artist/album filters + scroll/page-depth restore** (feedBack#857). The v3 Songs toolbar gains Artist and Album dropdowns (Album populates from the selected artist and stays disabled until one is chosen), backed by new exact, case-insensitive (`COLLATE NOCASE`) `artist` / `album` query params threaded through `MetadataDB._build_where` → `query_page` / `query_artists` / `query_stats` and the `/api/library`, `/api/library/artists`, `/api/library/stats` endpoints (the free-text `q` search stays fuzzy and composes with the exact filters). The artist/album catalog is fetched independently of the active artist/album selection so the dropdowns always list the full set for the current provider/search. The toolbar is now sticky so filter controls stay reachable when browsing deep libraries, and returning from the player restores the previous scroll position **and** the loaded infinite-scroll page depth via a `sessionStorage` snapshot keyed by a filter/sort/view state hash (invalidated whenever those change, so a filter change still resets to the top). Tests: `tests/test_library_filters.py` (backend artist/album filters), `tests/js/v3_songs_scroll.test.js` (state-hash + snapshot helpers).
+- **`note-detection` capability domain promoted — control plane (spec 009)** (slopsmith#727/#728, epic #828). New core host `static/capabilities/note-detection.js`: provider registry (kinds `midi`/`engine`/`js`, primitives `pitch.estimate`/`verify.target`), requester-owned context-scoped detection bindings (`open-binding`/`close-binding`/`set-target`/`clear-target` — each binding carries its own redacted tuning context, independent of the host's loaded song, per spec-009 FR-003), and hit/miss/verdict observability events (consumers own judgment). The legacy chart-coupled `highway.setNoteStateProvider` surface keeps working and is wrapped for compatibility-shim hit accounting. Diagnostics (`slopsmith.note_detection_capability.v1`) carry provider/binding summaries and bounded outcomes — no raw audio, device labels, or song identity. Migrating the chart path, Step Mode verify, minigames YIN, and the engine verifier onto bindings is the remainder of the spec-009 slice.
+- **`visualization` capability domain promoted (cap:6)** (slopsmith#828). New core host `static/capabilities/visualization.js` registers a provider-coordinator owning the highway renderer surface: commands `inspect` / `list-providers` / `select-renderer` / `clear-renderer` (selection delegates to the existing picker so persistence, WebGL2 gating, and fallback stay single-sourced), events `providers-refreshed` / `renderer-changed` / `renderer-ready` / `renderer-failed`. Legacy discovery (`type: "visualization"` manifests, `window.slopsmithViz_*` globals) keeps working unchanged and is accounted as compatibility shims with hit counts. `static/app.js` attributes every renderer change (auto-match / user-select / fallback) and auto-match outcomes into the domain. Diagnostics (`slopsmith.visualization_capability.v1`) carry provider ids/labels/context types, active renderer + selection source, last auto-match outcome, and last failure — no song filenames/titles. Per-panel (splitscreen) selection is a tracked follow-up.
+- **Viz picker routes notation arrangements** (slopsmith#826, epic #828). `window.slopsmith.currentSong` gains `hasNotation` (sibling of `hasDrumTab`) from the `song_info` frame's `has_notation` flag, so notation viz plugins (Staff View, Keys Highway 3D) can gate `matchesArrangement` on data presence instead of arrangement-name heuristics. When a notation-only arrangement (no wire notes — `file:` omitted per sloppak-spec §5.3) falls through Auto with no notation plugin installed, the built-in highway still takes the canvas but the Auto label reads "no notation view installed" and a one-shot dismissable hint points at the visualization picker — never a silently blank board.
+- **Keys instrument path in progression** (slopsmith#828). New `data/progression/paths/keys.json` (5 levels / 15 challenges at parity with the guitar path) plus keys-flavoured daily/weekly quest pool entries (`d.keys-one` "Ivory Tower", `w.keys-three` "Grand Recital"). `lib/progression.py::instrument_for_arrangement()` now attributes `type: piano|keys` arrangements — and names matching `keys`/`piano`/`keyboard`/`synth` on a word boundary — to the new `keys` instrument, so scored keys runs advance the path automatically. Purely content + attribution: no schema or API changes.
+- **v3 library: exact artist/album filters + scroll/page-depth restore** (slopsmith#857). The v3 Songs toolbar gains Artist and Album dropdowns (Album populates from the selected artist and stays disabled until one is chosen), backed by new exact, case-insensitive (`COLLATE NOCASE`) `artist` / `album` query params threaded through `MetadataDB._build_where` → `query_page` / `query_artists` / `query_stats` and the `/api/library`, `/api/library/artists`, `/api/library/stats` endpoints (the free-text `q` search stays fuzzy and composes with the exact filters). The artist/album catalog is fetched independently of the active artist/album selection so the dropdowns always list the full set for the current provider/search. The toolbar is now sticky so filter controls stay reachable when browsing deep libraries, and returning from the player restores the previous scroll position **and** the loaded infinite-scroll page depth via a `sessionStorage` snapshot keyed by a filter/sort/view state hash (invalidated whenever those change, so a filter change still resets to the top). Tests: `tests/test_library_filters.py` (backend artist/album filters), `tests/js/v3_songs_scroll.test.js` (state-hash + snapshot helpers).
 
 ### Fixed
-- **Input-setup wizard no longer collapses an audio device's driver-type variants into one entry.** On Windows the desktop engine enumerates the same interface once per host API (ASIO / Windows Audio / DirectSound), and the wizard's audio picker (`plugins/input_setup/screen.js`) de-duped the source list by display **label** — so the variants (which share a name) collapsed to a single choice, silently keeping whichever sorted first (often *not* the low-latency ASIO one the player wants). The audio-input capability already collapses true duplicates by `logicalSourceKey` (`_visibleInputSources` in `static/capabilities/audio-session.js`), and the variants each have a **distinct** key, so the wizard's extra label-collapse was redundant for real dupes and destructive for these — it also could drop the variant that was actually `selected`. Removed it; the picker now lists every selectable input. Pairs with feedBack-desktop's change to label each source with its driver type (e.g. "Focusrite (ASIO)") so the now-distinct entries are legible.
-- **v3 Songs grid now refreshes after a Settings rescan / DLC-folder change — no app restart needed.** On a fresh install, pointing at a DLC folder in Settings and running a scan left the Songs section empty until a restart (the scan *did* populate the library — `_background_scan` re-reads `config.json` fresh — but the v3 grid never reloaded). The Settings **Rescan / Full Rescan** handlers only refreshed the classic (v2) library via `loadLibrary()`; the v3 grid (`static/v3/songs.js`) had no listener for a scan it didn't start itself (only its own upload path self-refreshed via `watchUploadScan`), so its cached, pre-DLC (empty) DOM/snapshot survived a sidebar return until a full reload. The rescan handlers now emit a **`library:changed`** event (`static/app.js`); the v3 grid listens and **reloads if it's the active screen, else marks itself dirty** so the next entry does a full re-fetch instead of restoring the stale snapshot (a `_libraryDirty` short-circuit ahead of every cached-DOM fast-path in `onV3SongsScreenEnter`). Tests: `tests/js/v3_library_refresh.test.js` (the emit + the reload/dirty wiring).
-- **Edit Metadata modal: the Year is now editable.** You could set a year when authoring a pak but the Songs → Edit Metadata modal had no Year field, so it could never be changed afterward. The backend (`POST /api/song/<f>/meta`) already accepted and normalized `year` (writes it into the file via `songmeta`, survives a rescan) — only the UI omitted it. Added a **Year** input to `openEditModal()` (populated from the song's existing year) and included `year` in `saveEditModal()`'s POST body (`static/app.js`). Both the v3 card menu and the legacy edit button already pass the year through, so both surfaces get the field.
-- **Edit Metadata modal no longer closes when a click-drag is released on the backdrop.** Selecting text inside a field and releasing the mouse past the modal's edge dismissed the form without warning (the `click` event's target resolved to the backdrop), discarding the edit. Backdrop dismissal now requires the **mousedown to have started on the backdrop** too — tracked per-modal and decided by a new pure `_editModalShouldClose(clickTarget, modalEl, downOnBackdrop)` helper (`static/app.js`). Cancel / ✕ still close on a normal click. Tests: `tests/js/edit_metadata_modal.test.js` (year in the POST body + the backdrop-close decision table).
-- **Built-in diagnostic sloppak rebranded "Slopsmith" → "FeedBack" in the song name.** PR #586 renamed the file to `feedBack-diagnostic-basic-guitar.sloppak` but never regenerated the archive, so the manifest inside still carried `title: Slopsmith Diagnostic — Basic Guitar` / `artist: Slopsmith` (and the same heading in `DIAGNOSTIC.md`) — the stale name testers saw in the library/player and the onboarding calibration step, even though the build script, server, and docs all already say "FeedBack Diagnostic — Basic Guitar". Regenerated `docs/diagnostics/feedBack-diagnostic-basic-guitar.sloppak` from `docs/diagnostics/build_diagnostic_basic_guitar.py` so the committed artifact matches its source generator (title/artist/heading now "FeedBack"; chart, stem, and `diagnostic:` metadata unchanged). No code change — the rename in #586 just needed the rebuild.
-- **v3 song/lesson accuracy badges now refresh on the first return from a song — no restart needed.** PR #574 added a `stats:recorded` → in-place badge repaint, but the repaint never matched a card. The event (like `song:loading`) carries the filename **`encodeURIComponent`'d** — exactly as `playCard` hands it to `playSong` (the highway WS `decodeURIComponent`s it back) — whereas library cards key on the **decoded** `localFilename` (`data-fn`), and `/api/stats/best` is server-canonicalized to that same decoded key (`server.py` `_canonical_song_filename`). So `repaintAccuracy`'s `data-fn !== key` check rejected every card and `state.accuracy[encoded]` was `undefined`, leaving the just-earned badge stale until a full `render()` (app restart / search / re-enter the screen) — which is why it "came back after a restart." `static/v3/songs.js` now decodes the `stats:recorded` filename back into the card / `state.accuracy` key space via a small `decFn` helper before marking dirty and repainting (idempotent for already-decoded names; falls back to the original on malformed input so a real filename containing a literal `%` is never corrupted), so both the immediate repaint and the `onV3SongsScreenEnter` deferred path land on the right card. Tests: `tests/js/v3_songs_score_badge_refresh.test.js`.
-- **Escape now exits a song (and leaves Settings) even when a transport/rail control button holds keyboard focus.** Clicking a player control (Play / FF / RW / Restart) left that `<button>` focused, and `_shortcutDispatchBlocked()` in `static/app.js` treats any focused `INPUT/SELECT/TEXTAREA/BUTTON` as an "interactive control" and bails before the shortcut registry runs — so the player-scope `Escape → Back` shortcut never fired until the user clicked empty canvas to blur the control ("Escape in song not consistent"). Space already had a player-screen carve-out (#593) that let it fire through a focused control; Escape did not. Generalized that carve-out to Escape, scoped to the player **and** settings screens (both register an `Escape = Back` shortcut, and settings had the identical latent bug). The earlier guards are preserved and still win: text inputs are exempted first (Escape there clears/blurs the field), the Section Practice popover already claims Escape before the carve-out, and a true modal layered over the screen (`[role="dialog"][aria-modal="true"]` / `.feedBack-modal`) still traps Escape so it closes the modal rather than ejecting past it. Escape becomes a reliable, focus-independent "Back" — making it monotonic groundwork for an optional exit-confirm. Plugins that register a player-scope `Escape` shortcut benefit identically (they were broken the same way). Tests: `tests/browser/keyboard-shortcuts.spec.ts` (focused-button repro, text-input no-exit, no-escape-past-modal, Section Practice popover, settings twin-bug).
-- **The v3 "Up Next" pill can now be turned off — new "Show 'Up Next'" gameplay toggle (default ON).** The v0.3.0 player chrome's persistent upcoming-section pill (`#v3-upnext`, drawn by `static/v3/player-chrome.js`'s `updateUpNext()`) shipped with no off switch, so it always showed during playback whenever a section was upcoming — overlapping the top-right FPS HUD and ignoring the 3D-highway "Show 'Up Next' section card" checkbox (a *different*, in-canvas widget that was demoted to default-off precisely because this pill is the canonical readout). Users reading the pill as the same setting saw "disabled in settings but still there." Adds a real core toggle following the `autoplayExit` idiom: a client-only `showUpNext` `localStorage` pref (absence = enabled), a **Show "Up Next"** switch in the Gameplay settings tab (`static/v3/index.html`), reader/writer + `loadSettings()` hydration + a read-only `window.feedBack.showUpNext` getter in `static/app.js`, and a gate at the top of `updateUpNext()` that hides the pill when off. Disabling mid-playback hides it immediately; re-enabling re-shows it on the next chrome tick (~6 Hz). Added to `RESET_MAP.gameplay.local` in `static/v3/settings.js` so the Gameplay "Reset" restores the default-on state. Default ON = zero change for existing users. No Tailwind rebuild (plain markup + existing classes).
-- **v3 list/tree view brought to parity with the grid: select mode, parts chips, and song actions — plus a stale-CSS Docker fix.** Re-lands a previously-reverted change. **Frontend (`static/v3/songs.js`):** entering select mode no longer collapses the tree — `loadTree()` now captures the expanded artist groups (`details[open]` keyed by `data-artist`) before the "Loading…" wipe and restores them on rebuild, so toggling select mode (which re-renders via `reload()`) keeps groups open and selection usable; tree rows gain a display-only checkbox + selection ring, the same fav / save-for-later / overflow-menu cluster as the grid card (always shown, all bound by `wireCards()`), and a capture-phase select guard mirroring the grid so clicking a row or arrangement chip in select mode selects instead of playing (`<summary>` headers sit outside `[data-fn]`, so native expand/collapse is untouched). **Docker fix (`static/tailwind.min.css`):** the committed Tailwind stylesheet was stale — `.sm\:flex` (and the other utilities behind #582's `hidden sm:flex` arrangement chips and the new action cluster) were never compiled in, so they rendered `display:none` on the Docker build (which serves the committed CSS as-is; Desktop rebuilds from source so it looked fine). Regenerated with the pinned `tailwindcss@3.4.19` via `scripts/build-tailwind.sh` so Docker matches Desktop and #582's chips render on every Docker deploy. Regression tests: `tests/browser/v3-tree-select.spec.ts`.
-- **Space bar now plays/pauses on the player screen even when a sidebar nav link or rail button has focus.** When any `<button>` in the player rail (viz, audio, mixer, lyrics, plugins, advanced), a sidebar nav link, or a popover control held keyboard focus, pressing Space was swallowed by `_shortcutDispatchBlocked` → `_isInsideInteractiveControl` (which treats `BUTTON`/`A` as interactive), so the Space shortcut never reached the dispatcher and `togglePlay()` never ran. `_shortcutDispatchBlocked` (`static/app.js`) now extends the same carve-out already used for the Section Practice bar: while the player screen is active, Space is always routed through the shortcut system — the dispatcher calls `e.preventDefault()` before invoking the handler, so the focused element does not also activate. Text inputs (`_isTextInput`) remain exempted first, so typing space in a search/input field still works normally, and focus inside a true modal dialog (`role="dialog" aria-modal="true"` / `.feedBack-modal`) layered over the player is also exempted so Space reaches the modal's focused control (e.g. its Close button) instead of toggling playback behind it — non-modal player popovers/toasts (loop A/B, arrangement pin) stay covered. Regression tests in `tests/browser/keyboard-shortcuts.spec.ts` cover the focused-rail-button play/pause, the text-input exemption, and the modal-dialog exemption.
-- **A song's accuracy badge now updates on its library card right after you play it — no restart needed.** The v3 library (`static/v3/songs.js`) loaded the best-accuracy map (`/api/stats/best`) once into `state.accuracy` at render time and only ever refreshed it on a full re-render; the play→return flow takes the screen-entry fast-path that restores the cached grid DOM without re-fetching, so a just-earned score stayed invisible until the next restart re-ran `render()`. The `stats-recorder` now emits a `stats:recorded` event (carrying `filename`/`arrangement`) once the scored `POST /api/stats` resolves on the server — the correct moment, since `song:stop` fires before the POST completes. `songs.js` listens: if the library is the active screen it re-fetches `/api/stats/best` and patches the affected card/row badge in place; otherwise it marks the filename dirty and `onV3SongsScreenEnter` applies it on return (a failed fetch keeps the entry dirty to retry). Badge markup was factored into a shared `accuracyBadge(filename, variant)` (grid pill + tree-row percentage, both tagged `.fb-acc-badge`) so the in-place `repaintAccuracy` can find and replace them without a full list re-render (scroll/pagination preserved). The old empty `song:stop` "refresh lazily next render" placeholder is replaced.
-- **Changing Settings → 3D Highway → Fret spacing no longer ejects you to the home screen.** The `highway_3d` plugin's `h3dSetFretSpacing` was the lone 3D-highway setting that called `location.reload()` to apply — and since the SPA boots with `#home` as the active screen (`index.html` `.screen.active`), the reload dropped the user out of Settings onto the homescreen. It now applies live like every other 3D-highway setting: it rebinds the module-scope `_h3dFretUniform` flag (so panels mounted later this session pick up the new mode), recomputes the two `fretX`-derived scalars that were baked at init (`_fretLabelScaleRefW` for fret-label sprite scaling, `FRET_WIDTH_MID` for camera hysteresis), and broadcasts a `fretSpacing` change over the existing `_bgEmitChange` pub-sub so every mounted panel rebuilds its board via `buildBoard()`. Per-frame note geometry already reads `fretX` live and needs no rebuild. No page reload, so the Settings screen stays put. Source-level regression tests in `tests/js/highway_3d_fret_spacing.test.js` now pin the no-reload / live-rebuild behavior.
-- **v3 library scroll-restore no longer breaks the classic v2 UI or drops off-screen searches** (feedBack#857). Two regressions in the scroll-restore work above: (1) `playSong` remapped `home`-launched songs to return to the `#v3-songs` screen unconditionally, but `static/app.js` is shared with the v2 UI (served at `/v2` / `FEEDBACK_UI=v2`) where that screen does not exist — Esc-from-player then called `showScreen('v3-songs')`, which threw on the missing element and stranded the user on a blank screen with playback still running; the remap now applies only when `#v3-songs` is present. (2) The Songs screen-entry fast-path skips reloading to preserve scroll, but the global topbar search routed through it, so once Songs had been visited, searching from another screen navigated there without applying the new query; the screen now tracks the state hash each fetch reflects and refetches when it has drifted, keeping the scroll-preserving no-op only when nothing changed.
-- **An active custom highway renderer is no longer starved of `draw()` when it hides the canvas** (#819). The per-frame draw gate in `static/highway.js` bailed on `if (!_lastVisible) return`, which conflated two different "hidden" states: a genuine off-screen canvas (`offsetParent === null` — navigate-away / `display:none` splitscreen panel, #246) versus a renderer-set *override-hide* (`setVisible(false)`, where an opaque overlay covers the canvas but the active renderer keeps painting its own surface). The gate now only pauses everything for the off-screen case (and still pauses the default 2D renderer on an override-hide); the **active custom renderer** keeps receiving `draw()` through its own override-hide. The `highway:visibility` event still fires before the gate, so sibling overlay renderers (e.g. 3D Highway's `.h3d-wrap`) still pause. This is the core-side root cause behind the Tab View cursor freezing in single-player (feedBack#734; worked around plugin-side in feedBack-plugin-tabview#25).
-- **Screensaver no longer kicks in during windowed-mode playback** (#686). While a song is playing, `static/app.js` now holds a [Screen Wake Lock](https://developer.mozilla.org/en-US/docs/Web/API/Screen_Wake_Lock_API) (`navigator.wakeLock.request('screen')`) so the OS display/screensaver stays awake even though only audio + the highway animation are active and the keyboard/mouse are idle. The lock is acquired on `song:play`/`song:resume` and released on `song:pause`/`song:ended`/`song:stop` (kept only while actually playing), and re-acquired on `visibilitychange` when the tab refocuses (the API auto-releases a lock whenever the page is hidden). Both the HTML5 `<audio>` and JUCE desktop playback paths emit the same `song:*` events, so the fix covers both. In feedBack-desktop (Electron), where `navigator.wakeLock` is unreliable, it also drives a native `powerSaveBlocker` bridge via the optional `window.feedBackDesktop.power.setScreenAwake` hook when present; both calls degrade silently where unsupported. Note: the browser Wake Lock API is secure-context only, so in a plain browser this is active on `localhost` / HTTPS only — a session opened over plain HTTP to a LAN IP (e.g. `http://192.168.1.100:8000`) won't keep the screen awake; front it with HTTPS or use the desktop app (see README → reverse-proxy notes).
+- **v3 library scroll-restore no longer breaks the classic v2 UI or drops off-screen searches** (slopsmith#857). Two regressions in the scroll-restore work above: (1) `playSong` remapped `home`-launched songs to return to the `#v3-songs` screen unconditionally, but `static/app.js` is shared with the v2 UI (served at `/v2` / `SLOPSMITH_UI=v2`) where that screen does not exist — Esc-from-player then called `showScreen('v3-songs')`, which threw on the missing element and stranded the user on a blank screen with playback still running; the remap now applies only when `#v3-songs` is present. (2) The Songs screen-entry fast-path skips reloading to preserve scroll, but the global topbar search routed through it, so once Songs had been visited, searching from another screen navigated there without applying the new query; the screen now tracks the state hash each fetch reflects and refetches when it has drifted, keeping the scroll-preserving no-op only when nothing changed.
+- **An active custom highway renderer is no longer starved of `draw()` when it hides the canvas** (#819). The per-frame draw gate in `static/highway.js` bailed on `if (!_lastVisible) return`, which conflated two different "hidden" states: a genuine off-screen canvas (`offsetParent === null` — navigate-away / `display:none` splitscreen panel, #246) versus a renderer-set *override-hide* (`setVisible(false)`, where an opaque overlay covers the canvas but the active renderer keeps painting its own surface). The gate now only pauses everything for the off-screen case (and still pauses the default 2D renderer on an override-hide); the **active custom renderer** keeps receiving `draw()` through its own override-hide. The `highway:visibility` event still fires before the gate, so sibling overlay renderers (e.g. 3D Highway's `.h3d-wrap`) still pause. This is the core-side root cause behind the Tab View cursor freezing in single-player (slopsmith#734; worked around plugin-side in slopsmith-plugin-tabview#25).
+- **Screensaver no longer kicks in during windowed-mode playback** (#686). While a song is playing, `static/app.js` now holds a [Screen Wake Lock](https://developer.mozilla.org/en-US/docs/Web/API/Screen_Wake_Lock_API) (`navigator.wakeLock.request('screen')`) so the OS display/screensaver stays awake even though only audio + the highway animation are active and the keyboard/mouse are idle. The lock is acquired on `song:play`/`song:resume` and released on `song:pause`/`song:ended`/`song:stop` (kept only while actually playing), and re-acquired on `visibilitychange` when the tab refocuses (the API auto-releases a lock whenever the page is hidden). Both the HTML5 `<audio>` and JUCE desktop playback paths emit the same `song:*` events, so the fix covers both. In slopsmith-desktop (Electron), where `navigator.wakeLock` is unreliable, it also drives a native `powerSaveBlocker` bridge via the optional `window.slopsmithDesktop.power.setScreenAwake` hook when present; both calls degrade silently where unsupported. Note: the browser Wake Lock API is secure-context only, so in a plain browser this is active on `localhost` / HTTPS only — a session opened over plain HTTP to a LAN IP (e.g. `http://192.168.1.100:8000`) won't keep the screen awake; front it with HTTPS or use the desktop app (see README → reverse-proxy notes).
 
 ### Changed
-- **Practice plugin first-class sidebar slot now points at Virtuoso.** The bundled practice plugin was rebranded/re-homed from the SlopScale fork (`id: slopscale`) to `got-feedback/feedBack-plugin-virtuoso` (`id: virtuoso`); the desktop bundle swap is feedBack-desktop#31. `static/v3/shell.js` still promoted `slopscale`, whose id no longer ships — so `renderPromotedNav()` (gated on the plugin appearing in `/api/plugins`) would have found no match and the dedicated sidebar slot would have gone dark, dropping Virtuoso to the generic Plugins gallery. Update the NAV entry + `PROMOTED_PLUGINS` slot `slopscale` → `virtuoso` (`screen: plugin-virtuoso`, label "Virtuoso - Practice", same FeedBarcade anchor + `target` icon) so the practice plugin keeps its first-class entry. Also clear the now-dead `slopscale` id from the Plugins-gallery curated category map (`static/v3/plugins-page.js`) and add `virtuoso: 'practice'` as a defensive fallback (the manifest's `category: "practice"` is authoritative, so it lands on the practice board regardless), and refresh the stale SlopScale references in `README.md` + `docs/plugin-capability-inventory.md`. Must land with the bundle swap or the practice plugin regresses in the UI.
 - **3D highway: realistic curved metal frets.** The fret wires are now bowed `TubeGeometry` (the middle strings push away from the camera so the row of frets reads as wrapping a cylindrical neck — a depth cue) rendered with a lit `MeshStandardMaterial` instead of the old flat, straight `MeshBasicMaterial` boxes, so the scene's ambient + directional light glints across the rounded surface for a polished-steel look. The existing per-frame highlight is preserved unchanged: frets inside the active anchor still turn gold (`0xD8A636`), which under the metallic shading reads as brass. Metalness is kept moderate (0.4, not full-metal) because the scene has no envMap — a PBR full-metal surface would reflect black — with a dim emissive floor so frets stay legible down the fogged neck. Backported from the `highway_babylon` plugin's "hit-zone fret bars". All knobs (`FRET_BOW_DZ`, metalness/roughness/emissive) are tunable constants. `plugins/highway_3d` v3.25.0.
-- **3D highway: section + tone HUD cards now default OFF.** The v0.3.0 player chrome carries a persistent "Up Next" pill, making the in-canvas section card redundant by default (it doubled the readout, feedBack feedback); the tone HUD follows the same less-is-more default. Both remain available in Settings → 3D Highway (visibility/position/size unchanged); users who previously toggled either explicitly keep their stored preference — only the untouched default flips. `plugins/highway_3d` v3.24.1.
-- **Perf**: replace runtime Tailwind Play CDN with a prebuilt static stylesheet (`static/tailwind.min.css`). The Play CDN's runtime JIT scanned the DOM ~1.8x/sec on the main thread (~37 ms blocking spans), dropping ~26% of frames in long playback sessions with the 3D highway as default. Theme extensions (dark/accent/gold colors, Inter font) move to `tailwind.config.js`; regen via `bash scripts/build-tailwind.sh`. No runtime build step — the generated CSS is committed. Fixes feedBack-desktop#110.
+- **3D highway: section + tone HUD cards now default OFF.** The v0.3.0 player chrome carries a persistent "Up Next" pill, making the in-canvas section card redundant by default (it doubled the readout, slopsmith feedback); the tone HUD follows the same less-is-more default. Both remain available in Settings → 3D Highway (visibility/position/size unchanged); users who previously toggled either explicitly keep their stored preference — only the untouched default flips. `plugins/highway_3d` v3.24.1.
+- **Perf**: replace runtime Tailwind Play CDN with a prebuilt static stylesheet (`static/tailwind.min.css`). The Play CDN's runtime JIT scanned the DOM ~1.8x/sec on the main thread (~37 ms blocking spans), dropping ~26% of frames in long playback sessions with the 3D highway as default. Theme extensions (dark/accent/gold colors, Inter font) move to `tailwind.config.js`; regen via `bash scripts/build-tailwind.sh`. No runtime build step — the generated CSS is committed. Fixes slopsmith-desktop#110.
 - **Perf**: reduce per-frame allocations in the 2D highway chord + lyric render paths. `_ensureChordRenderCache` now also caches `sortedNotes` / `nonZeroNotes` / `nonZeroFrets` / `allMuted` / `hasMultipleNotes` (computed once per chord, invalidated on `src` / `_inverted` / `chordTemplates` change — the third key catches a stale `isOpen`-derived classification when the WS `chord_templates` message lands after the final `chords` chunk), so `drawChords` no longer re-sorts / re-filters / spreads min-max per visible chord per frame. The in-chord unison bend classification is folded inline (no `chordPositions.filter` × 2 per frame). `drawLyrics` memoizes `ctx.measureText` results in a two-level `Map<fontSize, Map<text, width>>` so cache hits don't allocate a composite string key. Lit-sustain shimmer in `drawSustains` swaps the 4 per-note-per-frame `Math.random()` calls for a 64-entry precomputed jitter LUT (xorshift32-seeded — the LUT contents are reload-stable and test-reproducible; rendered shimmer is deterministic per `createHighway()` instance, since the seed includes that instance's `_frameIdx`) indexed by `(frameIdx + n.s + ⌊n.t·60⌋)`, visually indistinguishable and allocation-free.
-- **Perf**: the load-adaptive render scale (`_adaptRenderScale`, #654) no longer visibly hunts up/down on passages that hover near the frame budget (testers saw "quality going up and down" with the 3D highway). Downscaling stays prompt to protect the frame rate, but **upscaling is now lazy**: a smaller step (×1.06 vs ×1.1) on a longer cooldown (`_AUTO_UPSCALE_COOLDOWN_MS` 2500 ms vs the 600 ms adjust cooldown), reset on any downscale, and gated by a predictive guard — it only upscales when the projected cost *after* the step (≈ cost × step², since draw cost tracks the pixel count) still clears the high budget. The scale therefore settles just inside the 7–12 ms deadband instead of oscillating across it. No new public API; the `_autoScaleMin` "Min res" floor is unchanged.
-
-### Removed
-- **`c` library hotkey ("Convert to .sloppak") removed from core.** Core hardcoded a plugin-specific shortcut: a documentation-only `registerShortcut({ key: 'c', scope: 'library' })` no-op plus a `c → button.sloppak-convert-btn` entry in the library keydown handler that fired the Sloppak Converter plugin's button. Per the plugins-own-their-behavior principle, core no longer ships this hotkey — the convert button still works by click, and the Sloppak Converter plugin can register its own `c` shortcut via `window.registerShortcut()` if keyboard access is wanted. The `f` (favorite) and `e` (edit) library hotkeys, which drive core buttons, are unchanged. Help-modal/registry tests in `tests/browser/keyboard-shortcuts.spec.ts` updated to drop the `c` assertions.
 
 ### Added
-- **Player progression: Mastery Rank, instrument-path challenges, daily/weekly quests, Decibels currency, cosmetics shop (spec 010).** Onboarding gains two steps: pick one or more **instrument paths** (Guitar / Bass / Drums — data-driven, more can ship as content) and a **calibration challenge** offer (play the bundled FeedBack Diagnostic with note detection at 100% accuracy — or skip; either way you reach **Mastery Rank 1**, and a skipped calibration can still be completed later from the Progress screen). Each path levels by completing a content-defined number of **challenges** (any order) from that level's set; Mastery Rank = onboarding rank + the sum of path levels, starting at 0 on a fresh install. The existing unified XP backend is untouched but the frontend renames it to **Decibels (dB)** — a spendable currency earned ONLY by playing (songs, FeedBarcade rounds, quest rewards; no real-money path exists or may be added) — with spend tracked in a separate wallet so lifetime earnings stay monotonic. Rotating **daily/weekly quests** (deterministic per period, lazy instantiation, local-midnight / Monday resets) award dB and feed `quest_completed` challenges. A new **Progress** screen (rank hero, per-path checklists, quest countdowns, add-a-path) and **Shop** screen (themes via CSS-variable swaps under `html[data-fb-theme]`, avatar frames; atomic balance-checked purchases — 402 on insufficient dB, 409 on re-buy) join the v3 nav, and the topbar badge now shows Rank + challenge-set progress + dB balance. All definitions live in `data/progression/` JSON (paths/levels/challenges, quest pools, shop catalog) — adding a rank, challenge, quest, or cosmetic is a content edit + restart, never code; invalid content degrades to logged warnings. New tables (additive + idempotent): `progression_state`, `player_paths`, `challenge_progress`, `quest_state`, `wallet`, `shop_owned`, `shop_equipped`. New endpoints: `GET /api/progression`, `POST /api/progression/paths|onboarding|events` (events whitelists `minigame_run`; `song_completed` stays server-derived inside `POST /api/stats`, which now resolves the instrument server-side and reports an additive `progression` outcome key), `GET /api/shop`, `POST /api/shop/buy|equip`; equipped cosmetics ride along on `GET /api/profile`. A new **`progression` capability domain** (core-owned, kind: command, safety: safe — `inspect`, `record-event`, `list-shop`, `buy-item`/`equip-item` gated on user action) emits `challenge-completed`/`quest-completed`/`path-level-up`/`rank-changed`/`db-changed`/`calibration-completed`/`cosmetic-equipped`, mirrored as `progression:*` window events, with a redaction-safe diagnostics contributor; backend plugins get the symmetric `record_progression_event` context hook (the bundled minigames hub reports runs through it, guarded for standalone). Spec: `specs/010-progression-domain/`. Tests: `tests/test_progression.py`, `tests/test_progression_api.py`. **Migration notes:** existing XP totals carry over as lifetime dB (balance = lifetime − spent); resetting a per-source XP contribution (e.g. a minigames profile reset) after spending can clamp the spendable balance to 0 until new dB is earned; drums-path v1 content uses currently-satisfiable goals (arcade rounds, quests, any-instrument plays) until drums scoring lands.
-- **3D highway score FX (notedetect game-scoring layer).** The bundled `highway_3d` renderer now visualizes the scoring layer shipped in feedBack-plugin-notedetect ≥1.13: floating **"+N" score pops** above each judged gem (sourced from the note-state provider's new `{ points, mult, popKey }` verdict fields — chord members share the chord-level `popKey`, so a chord pops once, not once per string), plus session-level FX from the new `notedetect:fx` event — a particle burst at the strike line on streak milestones (25/50/every 100), an expanding ring pulse on multiplier tier-ups (×2/×3/×4), and a brief red wash when a ≥10 streak breaks. Colors and the pop font follow the user's notedetect scoring-UI skin (`feedBack_notedetect_skin`: neon/esports/metal, refreshed live on the `notedetect:skin` bus event). Everything renders on the existing 2D overlay canvas from fixed-size slot pools — no Three.js geometry, no text-sprite cache traffic, near-zero cost when idle — and degrades to a silent no-op with older notedetect builds (the new fields/events simply never arrive). Splitscreen panels scope FX to their own detector instance via the bubbling per-panel `notedetect:fx` dispatch. `plugins/highway_3d` v3.24.1.
+- **Player progression: Mastery Rank, instrument-path challenges, daily/weekly quests, Decibels currency, cosmetics shop (spec 010).** Onboarding gains two steps: pick one or more **instrument paths** (Guitar / Bass / Drums — data-driven, more can ship as content) and a **calibration challenge** offer (play the bundled Slopsmith Diagnostic with note detection at 100% accuracy — or skip; either way you reach **Mastery Rank 1**, and a skipped calibration can still be completed later from the Progress screen). Each path levels by completing a content-defined number of **challenges** (any order) from that level's set; Mastery Rank = onboarding rank + the sum of path levels, starting at 0 on a fresh install. The existing unified XP backend is untouched but the frontend renames it to **Decibels (dB)** — a spendable currency earned ONLY by playing (songs, FeedBarcade rounds, quest rewards; no real-money path exists or may be added) — with spend tracked in a separate wallet so lifetime earnings stay monotonic. Rotating **daily/weekly quests** (deterministic per period, lazy instantiation, local-midnight / Monday resets) award dB and feed `quest_completed` challenges. A new **Progress** screen (rank hero, per-path checklists, quest countdowns, add-a-path) and **Shop** screen (themes via CSS-variable swaps under `html[data-fb-theme]`, avatar frames; atomic balance-checked purchases — 402 on insufficient dB, 409 on re-buy) join the v3 nav, and the topbar badge now shows Rank + challenge-set progress + dB balance. All definitions live in `data/progression/` JSON (paths/levels/challenges, quest pools, shop catalog) — adding a rank, challenge, quest, or cosmetic is a content edit + restart, never code; invalid content degrades to logged warnings. New tables (additive + idempotent): `progression_state`, `player_paths`, `challenge_progress`, `quest_state`, `wallet`, `shop_owned`, `shop_equipped`. New endpoints: `GET /api/progression`, `POST /api/progression/paths|onboarding|events` (events whitelists `minigame_run`; `song_completed` stays server-derived inside `POST /api/stats`, which now resolves the instrument server-side and reports an additive `progression` outcome key), `GET /api/shop`, `POST /api/shop/buy|equip`; equipped cosmetics ride along on `GET /api/profile`. A new **`progression` capability domain** (core-owned, kind: command, safety: safe — `inspect`, `record-event`, `list-shop`, `buy-item`/`equip-item` gated on user action) emits `challenge-completed`/`quest-completed`/`path-level-up`/`rank-changed`/`db-changed`/`calibration-completed`/`cosmetic-equipped`, mirrored as `progression:*` window events, with a redaction-safe diagnostics contributor; backend plugins get the symmetric `record_progression_event` context hook (the bundled minigames hub reports runs through it, guarded for standalone). Spec: `specs/010-progression-domain/`. Tests: `tests/test_progression.py`, `tests/test_progression_api.py`. **Migration notes:** existing XP totals carry over as lifetime dB (balance = lifetime − spent); resetting a per-source XP contribution (e.g. a minigames profile reset) after spending can clamp the spendable balance to 0 until new dB is earned; drums-path v1 content uses currently-satisfiable goals (arcade rounds, quests, any-instrument plays) until drums scoring lands.
+- **3D highway score FX (notedetect game-scoring layer).** The bundled `highway_3d` renderer now visualizes the scoring layer shipped in slopsmith-plugin-notedetect ≥1.13: floating **"+N" score pops** above each judged gem (sourced from the note-state provider's new `{ points, mult, popKey }` verdict fields — chord members share the chord-level `popKey`, so a chord pops once, not once per string), plus session-level FX from the new `notedetect:fx` event — a particle burst at the strike line on streak milestones (25/50/every 100), an expanding ring pulse on multiplier tier-ups (×2/×3/×4), and a brief red wash when a ≥10 streak breaks. Colors and the pop font follow the user's notedetect scoring-UI skin (`slopsmith_notedetect_skin`: neon/esports/metal, refreshed live on the `notedetect:skin` bus event). Everything renders on the existing 2D overlay canvas from fixed-size slot pools — no Three.js geometry, no text-sprite cache traffic, near-zero cost when idle — and degrades to a silent no-op with older notedetect builds (the new fields/events simply never arrive). Splitscreen panels scope FX to their own detector instance via the bubbling per-panel `notedetect:fx` dispatch. `plugins/highway_3d` v3.24.1.
 - **3D highway: slide direction arrows + gem-follow animation.** Slide notes now show a ›/‹ arrow indicating which way the slide goes — on the note/gem itself, as an early preview on the neck before the note arrives, and (optionally) chained further ahead for multi-leg slides — each independently toggleable in Settings → 3D Highway (`slideArrowApproachVisible`, `slideArrowNeckVisible`, `slideArrowChainPreviewVisible`). The note gem also now visually glides from its starting fret to the slide's destination over the note's sustain and holds there through the brief post-sustain linger, instead of snapping back to the starting fret — most noticeable on unpitched "slide to nothing" notes. `plugins/highway_3d` v3.25.2.
 - **3D highway: up to 3 upcoming-note ghost previews per string, with fade-in/grow.** Each string now previews up to 3 upcoming notes (was 1) on a fixed 0.6 s fade-in/grow ramp, so tight same-string runs no longer pop in at full size right before impact and the player can read note order ahead of time. `isBlocked` (the pre-impact ghost suppression in a note's last 150 ms) is now scoped to chord notes only — for lead notes it had been blinking the ghost out right before each sustained note in dense runs. (Slide notes stay excluded too, per the slide-arrow work above, since their gem glides off the start fret.) `plugins/highway_3d` v3.26.0.
 - **Enable/disable plugins from the v3 Pedalboard (footswitch backend).** Every `/api/plugins` entry now carries an `enabled` boolean (default `true`), and a new `POST /api/plugins/{plugin_id}/enabled` endpoint (`{"enabled": <bool>}` → `{"id", "enabled"}`) persists the choice to `CONFIG_DIR/plugin_state.json` (only non-default `enabled:false` entries are stored; a missing/corrupt file is tolerated and never crashes startup). The loader **skips disabled plugins at startup** — no requirements install, no `routes.setup()`, no screen/nav/capabilities — while still surfacing them in `/api/plugins` as a disabled entry (`status:"disabled"`, `enabled:false`) so the UI can show an "off" pedal you can switch back on. Toggling persists immediately and flips the in-memory flag so the next `/api/plugins` reflects it at once (a runtime-disabled plugin's already-mounted routes/screen remain until the next restart; re-enabling a startup-skipped plugin mounts on restart). A disabled plugin is **excluded from the capability pipeline** — its capability metadata is emptied in `/api/plugins`. Guard rails keep `capability_inspector` and `app_tour_*` always enabled (disable → `400`); unknown id → `404`; missing/non-boolean `enabled` → `400`. Backend only; the v3 Pedalboard frontend consumes this contract. Docs: `docs/plugin-v3-ui.md`.
-- **fee[dB]ack v0.3.0 rebrand + UI redesign (opt-in, isolated).** The visible product is being renamed from **FeedBack** to **fee[dB]ack** (the `[dB]` is a decibel pun on the practice "feedback" loop) alongside a full dashboard-style UI redesign. **Rebrand scope is the app + docs wordmark only** — the repository, Python package, ghcr Docker image, `CONFIG_DIR`, and `FEEDBACK_*` env vars all keep the `feedBack` name, so existing deployments and data are unaffected. The redesigned UI is additive and served behind a feature flag: `FEEDBACK_UI=v3` flips the `/` route to the new `static/v3/` shell, and `GET /v3` always serves it; the default `/` stays byte-identical to 0.2.9 until 0.3.0 flips the default. This release adds the `static/v3/` scaffold (navy app shell + styled fee[dB]ack wordmark, brand SVG + favicon + PWA manifest with 192/512 icons), an additive `fb` Tailwind color palette (legacy `dark`/`accent`/`gold` retained) with `static/v3/**` in the content globs, and the regenerated `static/tailwind.min.css`. Vanilla JS, prebuilt Tailwind, no Play CDN (Principle II). Shell wiring, screens, profile/scoring backends, and capability-runtime integration land in subsequent v0.3.0 changes.
+- **fee[dB]ack v0.3.0 rebrand + UI redesign (opt-in, isolated).** The visible product is being renamed from **Slopsmith** to **fee[dB]ack** (the `[dB]` is a decibel pun on the practice "feedback" loop) alongside a full dashboard-style UI redesign. **Rebrand scope is the app + docs wordmark only** — the repository, Python package, ghcr Docker image, `CONFIG_DIR`, and `SLOPSMITH_*` env vars all keep the `slopsmith` name, so existing deployments and data are unaffected. The redesigned UI is additive and served behind a feature flag: `SLOPSMITH_UI=v3` flips the `/` route to the new `static/v3/` shell, and `GET /v3` always serves it; the default `/` stays byte-identical to 0.2.9 until 0.3.0 flips the default. This release adds the `static/v3/` scaffold (navy app shell + styled fee[dB]ack wordmark, brand SVG + favicon + PWA manifest with 192/512 icons), an additive `fb` Tailwind color palette (legacy `dark`/`accent`/`gold` retained) with `static/v3/**` in the content globs, and the regenerated `static/tailwind.min.css`. Vanilla JS, prebuilt Tailwind, no Play CDN (Principle II). Shell wiring, screens, profile/scoring backends, and capability-runtime integration land in subsequent v0.3.0 changes.
 - **fee[dB]ack v0.3.0 app shell (sidebar + topbar + routing).** The v3 shell (`static/v3/index.html`) is now a re-chromed copy of the legacy app: the new left **sidebar** (HOME / LIBRARY groups) and **topbar** (secondary nav, search, Support, badge-cluster mount points) replace the hidden legacy navbar, and new `#v3-*` screens (dashboard/plugins/profile/playlists/saved) are added — while all legacy screens (`#home` library, `#favorites`, `#settings`, `#player`, `#audio`, plugin nav containers) are kept verbatim so `static/app.js` boots **unmodified** and the whole engine (player/highway, plugin loader, capabilities, audio, library, settings) is reused as-is. Navigation is the shared `window.showScreen` across `#v3-*`, reused legacy, and `#plugin-*` screens, with a responsive hamburger and a `localStorage`/`v3:`-namespaced shell. Plugin nav is mirrored into the sidebar from `/api/plugins` (UI placement is a deferred capability domain, so this uses the legacy loader, not capability dispatch). `static/v3/shell.js` wraps `window.showScreen` via the idempotent rehydration pattern to keep sidebar/topbar active-state in sync.
 - **fee[dB]ack v0.3.0 player profile + first-run onboarding + unified XP + streak.** Adds a single-user core **profile** (`profile`/`profile_progress`/`xp_profile` tables in `web_library.db`, additive + idempotent): display name + avatar, a stable `player_hash` (SHA-256 of the first name + a once-generated salt — stable across later renames; a future-leaderboard label, never auth), and a **streak** (any session on a calendar day keeps it; a missed day resets to 1). New endpoints: `GET/POST /api/profile`, `POST /api/profile/avatar` (base64, re-encoded to a ≤512px PNG under `CONFIG_DIR/avatars/`), `GET /api/profile/avatar/{name}` (safe-joined), `GET /api/profile/avatars` (bundled defaults under `static/v3/avatars/`), `GET /api/profile/progress` (one call for the badge), and `POST /api/xp/award`. **Unified XP:** `lib/xp.py` is the single XP curve (same math the minigames plugin shipped); the core `xp_profile` store is the one source of truth the profile badge reads, exposed to plugins via `context["award_xp"]`/`get_xp_progress`/`seed_xp`. The bundled **minigames** plugin now delegates XP to the core store (seeding once from its existing `profile.json` so earned levels carry over) — so song-play, minigames, and tutorials all feed one level. Frontend: a blocking first-run onboarding overlay (name + avatar grid + upload), the topbar profile badge (avatar, 🔥 streak, level + XP bar), and the `#v3-profile` screen. Tests: `tests/test_xp.py`, `tests/test_profile_api.py`.
-- **fee[dB]ack v0.3.0 song-stats store (best score + accuracy, plays, resume position).** A core `song_stats` table (`web_library.db`, additive + idempotent, PK `(filename, arrangement)`) records per-song/arrangement best/last score + accuracy, play count, and last position. Endpoints: `POST /api/stats` (scored session → `plays += 1`, `best_*` = max, `last_*` = new, plus **unified-XP award** `xp_for_run(score)` and a **streak** bump, both behind try/except so a side-effect failure never drops the stat write; or position-only `lastPlayPosition` → resume touch with no `plays` change), `GET /api/stats/{filename}` (aggregated across arrangements), `GET /api/stats/recent` (joined to song title/artist/art for "Jump back in"). Scoring stays frontend-driven: `static/v3/stats-recorder.js` tallies the `note:hit`/`note:miss` events the optional `feedBack-plugin-notedetect` already emits (and also accepts an explicit `note_detect:session-ended` summary), then POSTs on song end; it also persists resume position on pause/stop. No note-detect edit required — note-detection is a deferred capability domain, so the recorder uses those legacy events and degrades to "no accuracy" when the plugin isn't installed. Score/accuracy math is shared with the server via `lib/song_score.py`. Tests: `tests/test_song_score.py`, `tests/test_song_stats_api.py`.
+- **fee[dB]ack v0.3.0 song-stats store (best score + accuracy, plays, resume position).** A core `song_stats` table (`web_library.db`, additive + idempotent, PK `(filename, arrangement)`) records per-song/arrangement best/last score + accuracy, play count, and last position. Endpoints: `POST /api/stats` (scored session → `plays += 1`, `best_*` = max, `last_*` = new, plus **unified-XP award** `xp_for_run(score)` and a **streak** bump, both behind try/except so a side-effect failure never drops the stat write; or position-only `lastPlayPosition` → resume touch with no `plays` change), `GET /api/stats/{filename}` (aggregated across arrangements), `GET /api/stats/recent` (joined to song title/artist/art for "Jump back in"). Scoring stays frontend-driven: `static/v3/stats-recorder.js` tallies the `note:hit`/`note:miss` events the optional `slopsmith-plugin-notedetect` already emits (and also accepts an explicit `note_detect:session-ended` summary), then POSTs on song end; it also persists resume position on pause/stop. No note-detect edit required — note-detection is a deferred capability domain, so the recorder uses those legacy events and degrades to "no accuracy" when the plugin isn't installed. Score/accuracy math is shared with the server via `lib/song_score.py`. Tests: `tests/test_song_score.py`, `tests/test_song_stats_api.py`.
 - **fee[dB]ack v0.3.0 playlists, Saved for Later, and Continue-Playing.** Core playlist management (`playlists` + `playlist_songs` tables in `web_library.db`, additive + idempotent): create/rename/delete, add/remove/reorder songs, plus a reserved **Saved for Later** system playlist (created on first use; protected from rename/delete). Endpoints: `GET/POST /api/playlists`, `GET/PATCH/DELETE /api/playlists/{id}`, `POST /api/playlists/{id}/songs`, `DELETE /api/playlists/{id}/songs/{filename}`, `POST /api/playlists/{id}/reorder`, `POST /api/saved/toggle`, and `GET /api/session/continue` (derives the resume song + last position from `song_stats`, no new table). Frontend `static/v3/playlists.js` renders the `#v3-playlists` list + detail (drag-reorder, play, remove) and `#v3-saved`, and exposes `window.v3Saved.toggle()` for a "Save for later" affordance on song cards. Favorites reuse the existing favorites screen/API. Core REST, no capability domain. Tests: `tests/test_playlists_api.py`.
 - **fee[dB]ack v0.3.0 Dashboard / Home.** The `#v3-home` dashboard (matching the v0.3.0 design target) composes the new backends: a "Welcome back, {name}!" banner with a patch-notes link (`/api/version`), a hero card (Start Playing / Create Lobby), a **Continue-Playing** card (`/api/session/continue` → art, tuning chip, 4-segment progress; click resumes via `playSong` + best-effort seek), a stats row (audio-routing widget placeholder until prompt 18, library count from `/api/library/stats`, plugins count from `/api/plugins` where `status==="ready"`), and a **Recently Played** grid (`/api/stats/recent`) with per-song accuracy badges (good/mid/low ramp). Each widget fetches + renders independently and degrades gracefully (missing/empty endpoint → placeholder, never blocks first paint). `static/v3/dashboard.js`; re-renders on return to Home and on profile update.
-- **fee[dB]ack v0.3.0 tuner + instrument topbar badges.** The topbar gains an **instrument selector** (guitar/bass + string count + tuning + reference pitch) persisted via additive `/api/settings` fields (`reference_pitch` clamped 430–450, `instrument`, `string_count` 4–8, `tuning` name or semitone offsets); changing it emits `instrument:changed` so the note_detect scorer can re-tune (consumed once the external plugin adopts it). A **live tuner badge** stays idle until the user enables the mic (explicit gesture; `getUserMedia`), then shows a YIN note readout with a cents needle (green within ±5¢) using a new dependency-free `static/v3/tuner-core.js` (YIN + frequency→note/cents, honoring the reference pitch); clicking opens the full `feedBack-plugin-tuner` screen when installed. CPU-friendly (~20 Hz, paused when the tab is hidden, respects `prefers-reduced-motion`). Tests: `tests/test_settings_instrument.py`, `tests/js/tuner_core.test.js`.
+- **fee[dB]ack v0.3.0 tuner + instrument topbar badges.** The topbar gains an **instrument selector** (guitar/bass + string count + tuning + reference pitch) persisted via additive `/api/settings` fields (`reference_pitch` clamped 430–450, `instrument`, `string_count` 4–8, `tuning` name or semitone offsets); changing it emits `instrument:changed` so the note_detect scorer can re-tune (consumed once the external plugin adopts it). A **live tuner badge** stays idle until the user enables the mic (explicit gesture; `getUserMedia`), then shows a YIN note readout with a cents needle (green within ±5¢) using a new dependency-free `static/v3/tuner-core.js` (YIN + frequency→note/cents, honoring the reference pitch); clicking opens the full `slopsmith-plugin-tuner` screen when installed. CPU-friendly (~20 Hz, paused when the tab is hidden, respects `prefers-reduced-motion`). Tests: `tests/test_settings_instrument.py`, `tests/js/tuner_core.test.js`.
 - **fee[dB]ack v0.3.0 audio-routing widget (dashboard).** The dashboard's audio stat tile now reads the live audio session **through the capability runtime** — `audio-mix inspect` (route + faders + required kinds), `audio-input list-sources` (selected/available input), `audio-monitoring inspect` — and renders **Audio Input → VST/NAM/IR → Audio Output** with per-node state dots and a Connected/Not Connected line. It never touches `audio-mixer.js` internals or `nam_tone` routes directly; "Not Connected" is the honest browser default (no native route), and it degrades on `no-owner`/`no-handler`/`failed` or absent capabilities. Refreshes on `instrument:changed`, play/stop, capability audio events, and each Home visit. `static/v3/audio-routing.js`.
 - **fee[dB]ack v0.3.0 Plugins page.** The `#v3-plugins` screen renders the enriched `/api/plugins`: a "{N} active" header (`status==="ready"`), a card grid per plugin (icon, name, version, status pill with the error on failed, capability summary badges — declared domains / validation warnings / unsupported versions / shim hits / bundled / type), an **Open →** action that navigates to the plugin's injected `#plugin-<id>` screen, and All/Bundled/Visualizations filters. Surfaces a deep-link to the bundled **Capability Inspector** rather than re-implementing the graph. No new backend. `static/v3/plugins-page.js`.
 - **fee[dB]ack v0.3.0 Songs / Library screen (`#v3-songs`).** A native vanilla-JS library browser over the existing `/api/library*` endpoints: provider selector (via the `library` capability, not DOM scraping), grid + tree views, sort, format filter, a tri-state filter drawer (arrangements / stems / lyrics / tunings), topbar-driven search (debounced), infinite scroll, fb song cards with **accuracy badges** (good/mid/low ramp, batched via a new `GET /api/stats/best`), favorite + save-for-later affordances, and upload (reuses the existing uploader). The "Songs" sidebar nav now opens this screen. No regression to `/api/library*`. `static/v3/songs.js`.
-- **`ui.library-card-injection` capability + native song-card actions (fee[dB]ack v0.3.0).** New core capability (`static/capabilities/library-card-actions.js`, owner `core.ui.library-card-injection`, exposed as `window.feedBack.libraryCardActions`) lets plugins **register** per-song library-card actions (id, label, placement, applicability, enabled state, run handler) with `action-registered`/`action-result` events — replacing the legacy `.song-card` DOM-injection pattern (roadmap domain #9, now delivered as a frontend host). The native Songs grid renders registered actions in each card's "⋮" menu; the built-in **Edit metadata** and **Convert to E Standard (retune)** actions ship through it (`static/v3/card-actions-core.js`, calling the existing `openEditModal`/`retuneSong` globals). Songs cards also gain **arrangement chips** (play a specific arrangement) and a **multi-select** mode with batch **Add to playlist** / **Save for Later**. Recipe in `docs/capability-recipes.md`; tests in `tests/js/library_card_actions.test.js`. Migrating the external card-action plugins (Sloppak Converter, Find More, editor) onto `register(...)` is a follow-up.
+- **`ui.library-card-injection` capability + native song-card actions (fee[dB]ack v0.3.0).** New core capability (`static/capabilities/library-card-actions.js`, owner `core.ui.library-card-injection`, exposed as `window.slopsmith.libraryCardActions`) lets plugins **register** per-song library-card actions (id, label, placement, applicability, enabled state, run handler) with `action-registered`/`action-result` events — replacing the legacy `.song-card` DOM-injection pattern (roadmap domain #9, now delivered as a frontend host). The native Songs grid renders registered actions in each card's "⋮" menu; the built-in **Edit metadata** and **Convert to E Standard (retune)** actions ship through it (`static/v3/card-actions-core.js`, calling the existing `openEditModal`/`retuneSong` globals). Songs cards also gain **arrangement chips** (play a specific arrangement) and a **multi-select** mode with batch **Add to playlist** / **Save for Later**. Recipe in `docs/capability-recipes.md`; tests in `tests/js/library_card_actions.test.js`. Migrating the external card-action plugins (Sloppak Converter, Find More, editor) onto `register(...)` is a follow-up.
 - **`centOffset` exposed via `getSongInfo()`** — the arrangement `<centOffset>` field (float, cents) is now parsed from all chart sources (loose folder XML, sloppak wire format) and sent as `centOffset` in the `song_info` WebSocket message. Plugins can read `getSongInfo().centOffset` to obtain the arrangement's pitch-shift offset — commonly `-1200.0` for extended-range bass (one octave down) or a small non-zero value for true-tuned content (e.g. A443 ≈ +11.8 cents). Defaults to `0.0` when absent.
 - **`highway.getPhrases()` and `highway.getMastery()` public plugin API** — exposes phrase timing windows (`[{ index, start_time, end_time, max_difficulty }]`) and the current mastery slider value (`0..1`) as documented, stable plugin API. Both values were already in memory and reachable via internal names; this surfaces them with intent so plugins can implement section-aware logic (e.g. tracking accuracy per phrase, suppressing difficulty changes during a hard solo) without reaching into undocumented internals. Returns `null` when the song has no phrase data (GP imports, single-difficulty charts). Pair with the existing `hasPhraseData()` to gate phrase-aware code paths.
 - **Tailwind freshness guard + wider plugin scan.** A new `tailwind-fresh` CI job (`.github/workflows/tests.yml`) rebuilds `static/tailwind.min.css` with the pinned `tailwindcss@3.4.19` and hard-fails on any diff, so the committed prebuilt stylesheet can no longer silently lag source (after PR #411 removed the runtime Play CDN, a stale file shipped unstyled elements with no guard). The `tailwind.config.js` plugin content glob is widened to `./plugins/**/*.{js,html}`, which also scans non-`screen.js` plugin JS (e.g. `plugins/app_tour_*/script.js`) that was previously invisible to the build. Regenerating under the wider glob is a no-op for runtime behaviour — it only adds classes that were already used in source. Groundwork for the plugin `styles` capability (constitution 1.1.0, Principle II): runtime-installed plugins ship their own compiled CSS rather than relying on core's build-time scan.
 - **Plugin capability pipelines** — adds the first versioned capability coordination layer for plugin authors and support tooling. `/api/plugins` now exposes validated capability declarations, validation warnings, unsupported-version metadata, UI/runtime domain declarations, and compatibility shim summaries for legacy `nav` / `screen` / `settings` / `routes` / visualization surfaces. The browser runtime now tracks manifest participants separately from live handlers, explicit dispatch outcomes (`no-owner`, `no-handler`, `unsupported-command`, `incompatible-version`), claim lifecycle cleanup, manual override precedence, deterministic ownership conflicts, multi-provider ordering, shim hit counts, and a redaction-safe diagnostics snapshot capped at 64 KB. A bundled Capability Inspector plugin shows the live graph, and new docs cover the manifest schema, recipes, safety matrix, lifecycle cleanup, and diagnostics contract.
+- **Constitution 1.2.0 codifies capability-first plugins.** Principle III now makes `capability-pipelines.v1` manifest declarations the default Slopsmith-facing plugin contract, treats wrappers/private globals as compatibility bridges or capability gaps, and adds a concrete spec-kit Constitution Check gate for plugin capability metadata.
 - **Audio graph/session capability slice** — promotes `audio-mix`, `audio-input`, `audio-monitoring`, and coordinated `stems` diagnostics into the capability runtime. The new audio session host records song route/fader state, redaction-safe input sources, monitoring lifecycle outcomes, stem automation claims/overrides/orphans, and compatibility bridge hits for legacy faders, song volume, Stems master volume, 3D Highway analyser taps, audio startup barriers, and input source handoffs. `core.audio.session` coordinates `stems` without replacing the Stems plugin as the owner of actual stem playback/state.
 - **Audio-mix control plane** — makes `audio-mix` the player mixer source of truth. Core now exposes `list-faders`, `get-fader-value`, `set-fader-value`, `inspect-route`, and `inspect-analyser` through the capability runtime, routes native and compatibility-backed fader provider operations with a 2-second timeout, reports committed values back to the mixer UI, suppresses matching legacy faders when a native participant owns the same logical control, and expands audio-session diagnostics/Capability Inspector rendering for fader availability, source modes, bridge hits, route/analyser summaries, and timeout failures.
 - **Audio-input control plane** — makes `audio-input` the redaction-safe source of truth for instrument input discovery and lifecycle. Core now exposes `list-sources`, `select-source`, `open-source`, and `close-source` through the capability runtime, persists selected logical sources, keeps inspect/list/select prompt-free, routes provider `source.open`/`source.close` operations with bounded outcomes, shares compatible open sessions across requesters, suppresses compatibility-backed duplicate sources when a native provider owns the same logical key, and expands audio-session diagnostics/Capability Inspector rendering for selected input, open sessions, bridge hits, storage status, and permission/device failures without exposing raw device labels or live audio handles.
 - **Audio-monitoring control plane** — makes `audio-monitoring` the shared live-monitoring coordinator. Core now exposes provider registration/list/selection, explicit user-action `start`, requester-counted `stop`, prompt-free `inspect`/`monitoring.status`, and `set-direct-monitor` through the capability runtime. Monitoring starts integrate with selected `audio-input` readiness, background requesters can only attach to active compatible sessions, active sessions survive song/playback stops without auto-resuming after reload, native providers suppress compatibility-backed legacy monitor paths, and diagnostics/Capability Inspector now show providers, sessions, requesters, direct-monitor state, bridge hits, and distinct safe outcomes (`provider-selection-required`, `user-action-required`, `incompatible`, `unavailable`, `stopped`, etc.) without exposing raw audio/device data.
-- **Playback control plane** — promotes `playback` to an active core capability domain for song transport, timing, loop, route, requester/observer, bridge, and diagnostics state. Core now exposes `inspect`, user-authorized `start`, `pause`, `resume`, `stop`, `seek`, `set-loop`, and `clear-loop` through the capability runtime while `static/app.js` keeps raw `<audio>`/JUCE handles private behind a redaction-safe adapter. Playback diagnostics use pseudonymous targets in exported bundles, local display labels only in the Capability Inspector, bounded recent outcomes/events, and bridge accounting for `window.playSong`, legacy `song:*` events, `window.feedBack` transport helpers, loop helpers, and browser/native route handoff.
+- **Playback control plane** — promotes `playback` to an active core capability domain for song transport, timing, loop, route, requester/observer, bridge, and diagnostics state. Core now exposes `inspect`, user-authorized `start`, `pause`, `resume`, `stop`, `seek`, `set-loop`, and `clear-loop` through the capability runtime while `static/app.js` keeps raw `<audio>`/JUCE handles private behind a redaction-safe adapter. Playback diagnostics use pseudonymous targets in exported bundles, local display labels only in the Capability Inspector, bounded recent outcomes/events, and bridge accounting for `window.playSong`, legacy `song:*` events, `window.slopsmith` transport helpers, loop helpers, and browser/native route handoff.
 - **3D highway — Tone HUD, fret dividers, chord-diagram toggle, FPS counter.** The bundled `plugins/highway_3d` gains an amber **Tone-change HUD** (shows the active tone and the next scheduled tone change; position / size / visibility configurable in settings), a **fret-dividers** toggle (vertical dividers on the highway, on by default, via `h3dBgSetFretDividersVisible`), a **chord-diagram visibility** toggle (`h3dBgSetChordDiagramVisible`), and an **FPS counter** setting migrated to `BG_DEFAULTS.fpsVisible` (drops the legacy `h3d_showFps` localStorage key). Chord-diagram position is restricted to `tl`/`tr`; legacy `bl`/`br` values are coerced on load. Perf: accent-halo shell descriptors are pre-built per string in `initScene()` and the chord-verdict cache key is encoded as a number, eliminating per-frame allocations in the `drawNote()` and chord hot paths.
-- **Sloppak assembly preserves a short preview clip.** When a source chart carries a separate short browser-preview audio clip alongside the full song, the sloppak assembler now decodes it to `preview.ogg` at the sloppak root and records it under a new top-level `preview:` manifest key (POSIX relpath, same shape as `lyrics`/`cover`). A failed preview decode is logged at debug and skipped without aborting the overall build. Sources with no separate preview are unaffected. Older sloppak readers ignore the unknown `preview` key, so the change is purely additive (sloppak-spec.md §5.5 backward-compat). Documented in `docs/sloppak-spec.md` §2 alongside the other optional top-level keys. Enables [`feedBack-plugin-song-preview`](https://github.com/got-feedback/feedBack-plugin-song-preview) to render hover-to-listen previews for sloppaks without seeking into the full audio.
+- **Sloppak assembly preserves a short preview clip.** When a source chart carries a separate short browser-preview audio clip alongside the full song, the sloppak assembler now decodes it to `preview.ogg` at the sloppak root and records it under a new top-level `preview:` manifest key (POSIX relpath, same shape as `lyrics`/`cover`). A failed preview decode is logged at debug and skipped without aborting the overall build. Sources with no separate preview are unaffected. Older sloppak readers ignore the unknown `preview` key, so the change is purely additive (sloppak-spec.md §5.5 backward-compat). Documented in `docs/sloppak-spec.md` §2 alongside the other optional top-level keys. Enables [`slopsmith-plugin-song-preview`](https://github.com/got-feedback/feedback-plugin-song-preview) to render hover-to-listen previews for sloppaks without seeking into the full audio.
 - **Generic plugin asset route** — `GET /api/plugins/{plugin_id}/assets/{path}` serves arbitrary static files a plugin bundles under its own `assets/` directory (AudioWorklet modules, WASM, images, etc.), so plugins can self-host browser-fetchable assets without a CDN (Principle II). Containment is enforced by `lib/safepath.safe_join` against `<plugin>/assets/`, so `..` traversal, absolute paths, and NUL bytes cannot escape `assets/` to reach a plugin's Python modules. `.js` is served as `application/javascript`. First consumer: the stems plugin's pitch-preserving time-stretch worklet.
-- **Minigames framework — bundled as a core plugin (`plugins/minigames/`).** Promotes the upstream [`feedBack-plugin-minigames`](https://github.com/got-feedback/feedBack-plugin-minigames) repo into the core bundle so every FeedBack install gets the framework out of the box (same promotion path used for `highway_3d`). The plugin adds a top-level **Minigames** nav link (alongside Library / Favorites / Upload — not buried in the Plugins dropdown), a library-style card grid of installed minigame plugins, and a shared profile layer (XP, level, per-game leaderboards, cross-minigame unlocks) persisted under `CONFIG_DIR/minigames/` and opted into the settings export. Other plugins that want to ship a minigame add a `minigame` block to their `plugin.json` and call `window.feedBackMinigames.register(spec)`; the SDK exposes scoring (`createContinuous` runs a self-contained YIN tracker; `createDiscrete` / `createChord` wrap `note_detect`'s `createNoteDetector`), HUD primitives, run persistence, and a scheduler so individual minigames don't need their own DSP or backend. Backend endpoints live under `/api/plugins/minigames/{runs,profile,registry}`. The framework is plugin-shaped (not core code) per Principle III, but bundled so it ships with every install. First consumer: [`feedBack-plugin-flappy-bend`](https://github.com/got-feedback/feedBack-plugin-flappy-bend), shipped separately.
+- **Minigames framework — bundled as a core plugin (`plugins/minigames/`).** Promotes the upstream [`slopsmith-plugin-minigames`](https://github.com/got-feedback/feedback-plugin-minigames) repo into the core bundle so every Slopsmith install gets the framework out of the box (same promotion path used for `highway_3d`). The plugin adds a top-level **Minigames** nav link (alongside Library / Favorites / Upload — not buried in the Plugins dropdown), a library-style card grid of installed minigame plugins, and a shared profile layer (XP, level, per-game leaderboards, cross-minigame unlocks) persisted under `CONFIG_DIR/minigames/` and opted into the settings export. Other plugins that want to ship a minigame add a `minigame` block to their `plugin.json` and call `window.slopsmithMinigames.register(spec)`; the SDK exposes scoring (`createContinuous` runs a self-contained YIN tracker; `createDiscrete` / `createChord` wrap `note_detect`'s `createNoteDetector`), HUD primitives, run persistence, and a scheduler so individual minigames don't need their own DSP or backend. Backend endpoints live under `/api/plugins/minigames/{runs,profile,registry}`. The framework is plugin-shaped (not core code) per Principle III, but bundled so it ships with every install. First consumer: [`slopsmith-plugin-flappy-bend`](https://github.com/got-feedback/feedback-plugin-flappy-bend), shipped separately.
 - **Alpha-build heads-up banner** — when `/api/version` reports a version string containing "alpha" (case-insensitive), an amber banner appears at the top of the library section warning users that the build is in active development and may have bugs or breaking changes. The banner stays hidden on stable / beta / RC builds. No persistence or dismiss state — it's a passive notice, not a modal.
 - **Drum vocabulary expanded to 18 pieces** — adds `stack` (MIDI 30, from GM's extended-percussion range, unused by real drum-kit MIDIs) and `bell` (MIDI 80 "Mute Triangle", also unused in real drum-kit MIDIs) to `lib/drums.py` PIECES. Inserted in the iteration order so the editor / highway lane ordering is *hi-hat → stack → crash → … → ride bell → bell*. Both are cymbals; default shape `circle_jagged` (stack) / `circle_dot` (bell). Old drum tabs round-trip unchanged — the schema is permissive and existing piece-ids are untouched.
 - **GP / MIDI drum import surfaces unmapped notes** — `convert_drum_track_to_drumtab` (`lib/gp2rs.py`) and `convert_drum_track_from_midi` (`lib/midi_import.py`) gain an optional keyword-only `out_unmapped` parameter. Callers that pass an empty dict receive a per-MIDI record of every silently-skipped percussion note (`{midi: {"count": int, "times": [float, ...]}}`, times capped at 100 samples per note). This lets the editor plugin show a warning + manual-mapping UI on import instead of silently dropping unmapped notes. Default behavior unchanged for callers that don't opt in.
 
 - **Drum support from scratch** — drums are now a first-class arrangement type with their own JSON payload on disk and their own WS stream to the highway. New `lib/drums.py` defines the closed piece-id vocabulary (kick, snare, snare_xstick, hh_closed/open/pedal, tom_hi/mid/low/floor, crash_l/r, splash, china, ride, ride_bell), default GM-MIDI mappings, three preset lane configurations, and a permissive `drum_tab.json` validator. `lib/sloppak.py::load_song` reads the manifest's optional top-level `drum_tab:` key, parses + validates the JSON, and surfaces it on `LoadedSloppak.drum_tab`; the load stays permissive so a missing or malformed tab silently disables drums rather than failing the sloppak load. `/ws/highway/{filename}` gains two new message types — `drum_tab` (metadata + kit legend) and chunked `drum_hits` (500 hits per frame, same chunking as notes) — exposed to renderers via `bundle.drumTab`. `song_info` carries a `has_drum_tab` flag so viz pickers can auto-activate the drums highway regardless of which guitar arrangement is selected. `lib/gp2rs.py::convert_drum_track_to_drumtab` converts a Guitar Pro drum track to a `drum_tab.json` dict, preserving velocity verbatim, mapping hi-hat openness through the canonical piece-ids, and flagging flam / ghost / cymbal-choke articulations from GP effects. `lib/midi_import.py` gains `list_drum_tracks` + `convert_drum_track_from_midi` (channel-9 only) with heuristic flam-collapse (≤30 ms same-piece) and choke detection (cymbal note-off ≤120 ms). `docs/sloppak-spec.md` §5.3 promotes drum_tab from worked-example to canonical with the closed piece-id table and wire format. Sloppaks without a drum_tab are unaffected; legacy drums-as-guitar-notes sloppaks keep playing via the drums plugin's fallback decoder.
-- **Loose folder support** — a directory containing an audio file + arrangement XMLs, with optional `manifest.json` and album art, is now discovered, indexed, and playable as a first-class library format alongside Sloppak. The scanner walks `DLC_DIR` for non-preview audio files and treats each parent directory that also contains XMLs as a loose song. Metadata follows a `manifest.json` → XML tags → folder-name priority chain (see `lib/loosefolder.py`). Songs are tagged `format: "loose"`, render an amber `FOLDER` badge in the library, and are filterable via the new "Folder" option in the format dropdown. Audio uses the shared vgmstream/`convert_wem` pipeline, cached under `AUDIO_CACHE_DIR`. The chart `<offset>` from the first non-vocals XML is now propagated to the frontend via `song_info.offset` and applied in `highway.setTime()` so loose folders authored against non-silence-padded audio stay in sync. Pairs with the companion `feedBack-plugin-loosefolder` plugin which adds an in-player Fix Sync UI for nudging and saving offset corrections.
-- Highway note-state hook (#254). New `highway.setNoteStateProvider(fn)` lets a scorer plugin publish a per-note judgment (`'hit'` / `'active'` for a sustain currently held correctly / `'miss'`, or `{ state, alpha, color }`) so the renderer lights up the **gem itself** on a correct hit and keeps a sustain trail glowing while it's still being played right — instead of a separate overlay ring near the note. The built-in 2D highway honors it in `drawNote` / `drawSustains` / the chord-frame path (bright string colour + additive halo on hits, bright vs dim sustain trail, faint red wash on misses); the bundled 3D highway reads the same data via `bundle.getNoteState` (bright string-tinted outline + bright body + glowing sustain on hit/active, red outline + suppressed body on miss). Custom renderers opt in by calling `bundle.getNoteState(note, chartTime)`. note_detect registers the provider (and still owns its HUD / diagnostic miss markers / "currently detected" indicator); renderers that ignore the hook simply don't light gems. On a confirmed hit/active the renderers add a contained "sparkle/sizzle" on the note — the 2D highway: additive throbbing halo + flickering hot core + crackling spark lines (+ an expanding shockwave ring on a fresh strike) on the gem and a glowing/jittery sustain trail; the 3D highway: a few twinkling bright dots and short crackling arc segments hugging the note's rectangle (no bloom past the note), drawn on its overlay and projected through the camera so they ride the note. Also adds `highway.isDefaultRenderer()` so overlays that position with the 2D-highway helpers (`project` / `fretX`) can skip rendering when a custom renderer is active — fixes note_detect's miss markers appearing in random places over the 3D highway. New 3D-highway setting **Show note preview on the fretboard** (on by default) toggles the board-projection ghost — the translucent preview of the upcoming note on the fretboard surface. (Note: the companion change in the **note_detect plugin repo** turns its full-screen green/red edge flash off by default and adds a toggle to re-enable it — ships separately with note_detect, not in this feedBack release.)
-- Diagnostic bundle export (#166). New "Export Diagnostics" + "Preview Bundle" buttons in Settings produce a single redacted zip combining server logs (tail of `LOG_FILE`), system info (Python/OS/version), hardware probe (CPU model + cores + freq + RAM, GPU via `nvidia-smi`/`rocm-smi`/`system_profiler`, container/Electron/bare runtime detection), full plugin inventory with git SHA + remote URL (read directly from `.git/HEAD` so it works in minimal runtime images without `git` installed) + orphan/failed-to-load detection, the browser console transcript (all levels: log/info/warn/error/debug + window.onerror + unhandledrejection, 500-entry ring buffer), browser hardware (WebGL/WebGPU adapter info, navigator + userAgentData), filtered localStorage, and per-plugin contributed diagnostics. Top-level `manifest.json` lists every file with its versioned schema id (`system.hardware.v1`, `client.console.v1`, etc.) so AI agents can dispatch by schema. Redaction is on by default: DLC paths, song filenames (`<song:HASH8>` stable per-bundle), IPv4/IPv6 addresses, bearer tokens, and `key=`/`token=` query strings are replaced. Plugins opt their backend diagnostics in via a new `diagnostics` manifest field (`server_files` allowlist mirroring `settings.server_files` semantics, plus an optional `callable: "<module>:<function>"` resolved lazily via `load_sibling`). Frontend plugins push diagnostics via `window.feedBack.diagnostics.contribute(plugin_id, payload)`. Three new endpoints: `POST /api/diagnostics/export`, `GET /api/diagnostics/preview`, `GET /api/diagnostics/hardware`. Full bundle format spec in `docs/diagnostics-bundle-spec.md`.
+- **Loose folder support** — a directory containing an audio file + arrangement XMLs, with optional `manifest.json` and album art, is now discovered, indexed, and playable as a first-class library format alongside Sloppak. The scanner walks `DLC_DIR` for non-preview audio files and treats each parent directory that also contains XMLs as a loose song. Metadata follows a `manifest.json` → XML tags → folder-name priority chain (see `lib/loosefolder.py`). Songs are tagged `format: "loose"`, render an amber `FOLDER` badge in the library, and are filterable via the new "Folder" option in the format dropdown. Audio uses the shared vgmstream/`convert_wem` pipeline, cached under `AUDIO_CACHE_DIR`. The chart `<offset>` from the first non-vocals XML is now propagated to the frontend via `song_info.offset` and applied in `highway.setTime()` so loose folders authored against non-silence-padded audio stay in sync. Pairs with the companion `slopsmith-plugin-loosefolder` plugin which adds an in-player Fix Sync UI for nudging and saving offset corrections.
+- Highway note-state hook (#254). New `highway.setNoteStateProvider(fn)` lets a scorer plugin publish a per-note judgment (`'hit'` / `'active'` for a sustain currently held correctly / `'miss'`, or `{ state, alpha, color }`) so the renderer lights up the **gem itself** on a correct hit and keeps a sustain trail glowing while it's still being played right — instead of a separate overlay ring near the note. The built-in 2D highway honors it in `drawNote` / `drawSustains` / the chord-frame path (bright string colour + additive halo on hits, bright vs dim sustain trail, faint red wash on misses); the bundled 3D highway reads the same data via `bundle.getNoteState` (bright string-tinted outline + bright body + glowing sustain on hit/active, red outline + suppressed body on miss). Custom renderers opt in by calling `bundle.getNoteState(note, chartTime)`. note_detect registers the provider (and still owns its HUD / diagnostic miss markers / "currently detected" indicator); renderers that ignore the hook simply don't light gems. On a confirmed hit/active the renderers add a contained "sparkle/sizzle" on the note — the 2D highway: additive throbbing halo + flickering hot core + crackling spark lines (+ an expanding shockwave ring on a fresh strike) on the gem and a glowing/jittery sustain trail; the 3D highway: a few twinkling bright dots and short crackling arc segments hugging the note's rectangle (no bloom past the note), drawn on its overlay and projected through the camera so they ride the note. Also adds `highway.isDefaultRenderer()` so overlays that position with the 2D-highway helpers (`project` / `fretX`) can skip rendering when a custom renderer is active — fixes note_detect's miss markers appearing in random places over the 3D highway. New 3D-highway setting **Show note preview on the fretboard** (on by default) toggles the board-projection ghost — the translucent preview of the upcoming note on the fretboard surface. (Note: the companion change in the **note_detect plugin repo** turns its full-screen green/red edge flash off by default and adds a toggle to re-enable it — ships separately with note_detect, not in this slopsmith release.)
+- Diagnostic bundle export (#166). New "Export Diagnostics" + "Preview Bundle" buttons in Settings produce a single redacted zip combining server logs (tail of `LOG_FILE`), system info (Python/OS/version), hardware probe (CPU model + cores + freq + RAM, GPU via `nvidia-smi`/`rocm-smi`/`system_profiler`, container/Electron/bare runtime detection), full plugin inventory with git SHA + remote URL (read directly from `.git/HEAD` so it works in minimal runtime images without `git` installed) + orphan/failed-to-load detection, the browser console transcript (all levels: log/info/warn/error/debug + window.onerror + unhandledrejection, 500-entry ring buffer), browser hardware (WebGL/WebGPU adapter info, navigator + userAgentData), filtered localStorage, and per-plugin contributed diagnostics. Top-level `manifest.json` lists every file with its versioned schema id (`system.hardware.v1`, `client.console.v1`, etc.) so AI agents can dispatch by schema. Redaction is on by default: DLC paths, song filenames (`<song:HASH8>` stable per-bundle), IPv4/IPv6 addresses, bearer tokens, and `key=`/`token=` query strings are replaced. Plugins opt their backend diagnostics in via a new `diagnostics` manifest field (`server_files` allowlist mirroring `settings.server_files` semantics, plus an optional `callable: "<module>:<function>"` resolved lazily via `load_sibling`). Frontend plugins push diagnostics via `window.slopsmith.diagnostics.contribute(plugin_id, payload)`. Three new endpoints: `POST /api/diagnostics/export`, `GET /api/diagnostics/preview`, `GET /api/diagnostics/hardware`. Full bundle format spec in `docs/diagnostics-bundle-spec.md`.
 - Structured logging bootstrap (phase 1 of #155). Three new environment variables control server log output: `LOG_LEVEL` (default `INFO`), `LOG_FORMAT` (`text` for coloured console, `json` for one-JSON-object-per-line suitable for Loki/ELK/Promtail), and `LOG_FILE` (optional path, rotated at 10 MB with 5 backups). HTTP responses now include a `X-Request-ID` correlation header (via `CorrelationIdMiddleware`); the same request ID appears as `request_id` in structured log lines emitted via the stdlib `logging` / `structlog` APIs during that request.
-- Structured logging migration completed (phase 2 of #155, #159, #242). The 42 `print()` calls and 6 `traceback.print_exc()` calls across `server.py` and `lib/` have been migrated to levelled `feedBack.*` loggers. Silent `except: pass` blocks in `lib/sloppak.py` and `lib/sloppak_convert.py` now surface as `log.warning` / `log.debug` with the exception attached. WebSocket handlers (`highway_ws`, `ws_retune`) bind a `ws_conn_id` contextvar at accept time so every log line within a session carries a connection ID. A CI grep guard in `.github/workflows/tests.yml` fails the build if either `print(` or `traceback.print_exc(` reappears in `server.py` or `lib/`.
+- Structured logging migration completed (phase 2 of #155, #159, #242). The 42 `print()` calls and 6 `traceback.print_exc()` calls across `server.py` and `lib/` have been migrated to levelled `slopsmith.*` loggers. Silent `except: pass` blocks in `lib/sloppak.py` and `lib/sloppak_convert.py` now surface as `log.warning` / `log.debug` with the exception attached. WebSocket handlers (`highway_ws`, `ws_retune`) bind a `ws_conn_id` contextvar at accept time so every log line within a session carries a connection ID. A CI grep guard in `.github/workflows/tests.yml` fails the build if either `print(` or `traceback.print_exc(` reappears in `server.py` or `lib/`.
 - **Lyrics Karaoke plugin** — end-to-end karaoke setup for Sloppak songs in one workflow. The setup screen shows a per-song checklist (vocals stem / synced lyrics / per-syllable pitch) and a single "Build Karaoke" button that runs whatever's missing: Whisper alignment of pasted lyric text against the vocals stem, then `librosa.pyin` pitch extraction. Both artifacts persist inside the Sloppak (`lyrics.json`, `vocal_pitch.json`). In the player, a "Karaoke" toggle swaps the text-lyrics overlay for a horizontal pitch ribbon (one bar per syllable, vertically positioned by pitch, sweeping playhead).
 - Settings export/import (#113). Two buttons on the Settings page bundle server config, browser localStorage, and opted-in plugin server-side files into a single versioned JSON file for backup, migration, or sharing a calibrated setup. Server-side import is all-or-nothing for safety-critical failures: phase-1 validates the entire bundle (schema, path-traversal, encoding) before any disk writes; phase-2 commits each file via temp+rename. Plugin-state mismatches between export and import are handled leniently: files referenced for a plugin that isn't loaded are skipped with a warning, files referenced for a plugin whose manifest no longer declares them are skipped with a warning, and localStorage is merged (not cleared) so first-run defaults from plugins installed after the export are preserved. Path-traversal, absolute paths, schema mismatch, and decode failures remain hard refusals. Plugins opt their server-side files in by declaring `settings.server_files` in `plugin.json` (list of relpaths under `CONFIG_DIR`; trailing `/` denotes a directory).
 - Library filtering by parts present or missing (#129, #69). New right-side Filters drawer (single button next to the format/sort row, with active-filter count badge and dismissible chips below) lets you require or exclude arrangements (Lead/Rhythm/Bass/Combo), specific stems on Sloppaks (drums/bass/vocals/piano/other), lyrics, and tuning. Multi-select within an axis is OR (Lead OR Rhythm); cross-axis is AND. State persists across reloads. New endpoint `GET /api/library/tuning-names` returns distinct tunings present in the library, ordered by musical distance.
@@ -114,17 +78,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`highway.getLyrics()` accessor.** `createHighway()` now exposes the parsed timed lyric syllables (`[{t, d, w}]`) via `getLyrics()`, mirroring `getBeats()`/`getSections()`, so overlay plugins can render karaoke without opening a second highway WebSocket. Pure accessor; no behavior change.
 
 ### Changed
-- **Perf (3D highway, feedBack#226)**: pre-warm `plugins/highway_3d/screen.js` object pools at board init. Previously the pool factory grew lazily on first `.get()` past the high-water mark, allocating a fresh `T.Mesh` mid-rAF on dense 7/8-string charts and stalling those frames; the meshes were then permanently added to `noteG` (the pool only hides on `reset()`, never removes), bloating the scene graph for the rest of the session. Pre-warming spends the cost up front. Fold the per-frame `updateStringHighlights()` per-string loop with the post-call `mGlow`/`mAccentCore` emissive writes — one walk over the per-string scratch arrays instead of two. Replace `longestConsecutiveRun`'s per-call array allocations with a `{start, len}` index pair (trades two per-call sub-array allocations for one small 2-key object — net reduction in per-visible-chord allocation churn). Opt-in perf bench harness via `?h3dbench=1` URL param: `console.log` p50/p95/max for six update() segments every 5 seconds; when the URL flag is absent the mark helpers are bound to empty functions at renderer-instance init (each `createHighway()` panel re-checks the flag), so the hot-path calls are no-ops with negligible overhead (typically JIT-inlined).
+- **Perf (3D highway, slopsmith#226)**: pre-warm `plugins/highway_3d/screen.js` object pools at board init. Previously the pool factory grew lazily on first `.get()` past the high-water mark, allocating a fresh `T.Mesh` mid-rAF on dense 7/8-string charts and stalling those frames; the meshes were then permanently added to `noteG` (the pool only hides on `reset()`, never removes), bloating the scene graph for the rest of the session. Pre-warming spends the cost up front. Fold the per-frame `updateStringHighlights()` per-string loop with the post-call `mGlow`/`mAccentCore` emissive writes — one walk over the per-string scratch arrays instead of two. Replace `longestConsecutiveRun`'s per-call array allocations with a `{start, len}` index pair (trades two per-call sub-array allocations for one small 2-key object — net reduction in per-visible-chord allocation churn). Opt-in perf bench harness via `?h3dbench=1` URL param: `console.log` p50/p95/max for six update() segments every 5 seconds; when the URL flag is absent the mark helpers are bound to empty functions at renderer-instance init (each `createHighway()` panel re-checks the flag), so the hot-path calls are no-ops with negligible overhead (typically JIT-inlined).
 - **License**: Relicensed to AGPL-3.0-only. Prior versions claimed MIT in the README, but the bundled desktop build statically links JUCE 8 (AGPL-3.0), so AGPL terms have effectively governed the desktop distribution since JUCE was added. AGPL-3.0-only is now the canonical license for the project — see [LICENSE](LICENSE) and [CONTRIBUTING.md](CONTRIBUTING.md) (DCO sign-off + plugin licensing policy). Bundled and vendored third-party code keeps its original license.
 - Tuning sort is now ordered by musical distance from E Standard (#22) instead of alphabetical: E Standard first, then Drop D / F Standard at distance 2, then Eb Standard / F# Standard at distance 6, etc. Within a magnitude tier, down-tuned variants come before up-tuned, then alphabetical.
-- Settings page restructured into separate "FeedBack" (core) and "Plugins" sections, with each plugin's settings rendered as a collapsible panel (collapsed by default). "Plugin Updates" moved into the Plugins section.
+- Settings page restructured into separate "Slopsmith" (core) and "Plugins" sections, with each plugin's settings rendered as a collapsible panel (collapsed by default). "Plugin Updates" moved into the Plugins section.
 - **Lyrics Sync** is now a redirect stub. Its alignment + save endpoints moved into the new Lyrics Karaoke plugin alongside the pitch extraction. Existing nav entries and bookmarks land on a "moved" page that auto-redirects to the merged plugin.
 
 ### Security
 - **Path traversal in archive extractors and library path resolution.** `lib/sloppak.py::_unpack_zip` and `server.py::_resolve_dlc_path` previously concatenated attacker-controlled entry names or filenames directly onto the extraction or library directory, so a crafted sloppak zip member or library filename with `..` segments, an absolute path, or backslash separators could write or read outside the intended directory. Any code path that unpacks a user-supplied archive (library upload, click-to-play, retune) or resolves a library path was reachable. Both locations now delegate to a new `lib/safepath.py::safe_join` helper that resolves each destination once and rejects entries that don't fall under the target directory; rejected entries are logged and skipped, the rest of the archive still extracts. The stem-split paths in `lib/sloppak_convert.py::split_stems` and `scripts/split_stems.py` previously called `ZipFile.extractall()` directly on user-supplied sloppaks; both now delegate to the same hardened `lib/sloppak.py::_unpack_zip` so every sloppak-unzip site in the codebase shares one containment guarantee. Tests in `tests/test_archive_traversal.py` and `tests/test_safepath.py` pin the contract for `../`, deep traversal, absolute paths, mixed `subdir/../../` forms, Windows-style separators, NUL bytes, names that resolve to the unpack root, and symlinked roots.
 
 ### Fixed
-- E Standard retune now stays metadata-consistent across a chart's arrangement files (feedBack-plugin-notedetect#50). Previously the retune path could shift the audio and update manifests while leaving some arrangement metadata untouched, so `load_song()` later exposed the *original* tuning at runtime. `lib/retune.py` now updates every arrangement's tuning metadata consistently before applying the E Standard tuning, and raises on a partial update instead of silently packing split tuning metadata. EStd files generated before this fix should be re-converted so their metadata is consistent.
+- E Standard retune now stays metadata-consistent across a chart's arrangement files (slopsmith-plugin-notedetect#50). Previously the retune path could shift the audio and update manifests while leaving some arrangement metadata untouched, so `load_song()` later exposed the *original* tuning at runtime. `lib/retune.py` now updates every arrangement's tuning metadata consistently before applying the E Standard tuning, and raises on a partial update instead of silently packing split tuning metadata. EStd files generated before this fix should be re-converted so their metadata is consistent.
 - Keyboard shortcut help now opens from the Player/3D Highway context when Linux/Electron reports Shift+Slash as `key="/"`, including while player controls such as the visualization picker are focused (#598).
 - 3D Highway left-handed mode now has regression coverage for fret-axis mirroring, board rebuilds on runtime lefty changes, and mirrored camera state including the lookahead target and shoulder offset; the maintainer guide no longer claims the renderer ignores `bundle.lefty` (#321).
 - Chord-level `fretHandMute` is now parsed into each note's `fret_hand_mute` (wire `fhm`) instead of being folded into `mute` (`mt`), matching `_parse_note` and preserving wire-format fidelity for both the template-expanded (synthetic-note) and explicit-`chordNote` paths. The 3D highway renders the fret-hand-mute X for `mt` *or* `fhm` notes, so the muted-chord overlay still shows. Also fixes the per-note fret-connector label vanishing exactly at the hit line (the fade now holds full opacity through `dt = 0`).
@@ -133,8 +97,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Demucs stem split failing on Windows desktop with `OSError: Could not load this library: libtorchcodec_core4.dll` or `ImportError: TorchCodec is required for save_with_torchcodec`. The demucs subprocess now bootstraps a `torchaudio.save` → `soundfile.write` shim before importing demucs, sidestepping the torchcodec dependency entirely. The override stays in place across torchaudio versions — soundfile's WAV writes are behaviorally equivalent for demucs's float32 outputs.
 - Splitscreen pop-out windows briefly flashed the library/song grid before showing the popped panel. A popup loads the full app (whose default screen, `#home`, is the library) and only swaps to the player once the splitscreen plugin loads; app init now detects `?ssFollower=1` and switches to the player screen up front, so the popup shows player chrome the whole time.
 - Sloppak assembly dropped all tone data — affected sloppaks showed no signal chain in the Tones plugin and no tone-change markers on the highway. The assembler (`lib/sloppak_convert.py`) now lifts each arrangement's tones from the source chart via the new `lib/tones.py` helper and embeds them inline in the arrangement JSON under a `tones` key (`base`, `changes`, `definitions` — see `docs/sloppak-spec.md` §3.9). The highway WebSocket reads `base`/`changes` for sloppaks, and the Tones plugin (≥ 1.1.0) reads `definitions` to render the gear chain. Sloppaks built before this release carry no tone data and must be rebuilt from their source chart to gain it.
-- Tab View (feedBack-plugin-tabview ≥ 3.0.1): the bottom row of tablature was permanently hidden behind the player controls bar (#336). The overlay reserved 60px at the *top* (clearing the transparent HUD) and extended all the way to the bottom of `#player`, where the opaque `#player-controls` (z-index 10) drew over the last row. The overlay now measures `#player-hud` and `#player-controls` dynamically and insets both edges; a `ResizeObserver` on the controls bar re-runs the inset when it wraps to a second row on narrow viewports.
-- Tab View (feedBack-plugin-tabview ≥ 3.0.1): the cursor highlight led playback by roughly one beat (#336). alphaTab snaps `tickPosition` to the start of the *next* beat, so the cursor would race ahead by 500ms+ at typical tempos. The plugin now sends `tickPosition` one beat earlier so the snap lands on the current beat, and the highlight overlay tracks the bar cursor (`.at-cursor-bar`) instead of the next-beat cursor (`.at-cursor-beat`).
+- Tab View (slopsmith-plugin-tabview ≥ 3.0.1): the bottom row of tablature was permanently hidden behind the player controls bar (#336). The overlay reserved 60px at the *top* (clearing the transparent HUD) and extended all the way to the bottom of `#player`, where the opaque `#player-controls` (z-index 10) drew over the last row. The overlay now measures `#player-hud` and `#player-controls` dynamically and insets both edges; a `ResizeObserver` on the controls bar re-runs the inset when it wraps to a second row on narrow viewports.
+- Tab View (slopsmith-plugin-tabview ≥ 3.0.1): the cursor highlight led playback by roughly one beat (#336). alphaTab snaps `tickPosition` to the start of the *next* beat, so the cursor would race ahead by 500ms+ at typical tempos. The plugin now sends `tickPosition` one beat earlier so the snap lands on the current beat, and the highlight overlay tracks the bar cursor (`.at-cursor-bar`) instead of the next-beat cursor (`.at-cursor-beat`).
 
 ### Migration notes
 - **Constitution amended to 1.1.0 (Principle II — Vanilla Frontend).** Prebuilt Tailwind (`static/tailwind.min.css`) is now codified as non-negotiable: no Play CDN / runtime CSS JIT anywhere, core or plugin. Plugin authors: a plugin that uses Tailwind classes not guaranteed in core — especially arbitrary values like `w-[37px]` — MUST ship its own compiled stylesheet via the new `styles` manifest key, built with `corePlugins.preflight = false`. Plugins that use only core-guaranteed utilities, or that ship no Tailwind at all, need no change. Contributors: after adding any Tailwind class to core or a bundled plugin, run `bash scripts/build-tailwind.sh` and commit the regenerated CSS, or the `tailwind-fresh` CI job fails.

CLAUDE.md

@@ -1,639 +1,22 @@
-# FeedBack — AI Agent Guide
+# CLAUDE.md
 
-FeedBack is a self-hosted web app for browsing, playing, and practicing interactive music notation, built around its own open `.sloppak` chart format. Charts come from importing Guitar Pro (GP5/GP8) or MusicXML, or from authoring in the built-in editor. It runs as a Docker container with a FastAPI backend (`server.py`), vanilla JavaScript frontend (`static/`), shared Python libraries (`lib/`), and an extensive plugin system (`plugins/`). There are no frontend frameworks — everything is plain JS, HTML, and Tailwind CSS.
+Claude Code memory file. This repo's canonical project orientation lives in [`AGENTS.md`](AGENTS.md) - the cross-tool standard read by Cursor, Copilot, Codex, Aider, Cline, and others. The line below uses Claude Code's `@`-import to inline AGENTS.md into this memory file, so there's a single source of truth and no drift between two near-duplicate files.
 
-## Architecture Quick Reference
+@AGENTS.md
 
-```
-server.py              FastAPI app — library API, WebSocket highway, plugin loading
-static/
-  app.js               Main frontend — screens, library views, player, plugin loader
-  highway.js           Canvas note highway renderer (createHighway factory)
-  index.html           Single-page app shell
-  style.css            Custom CSS loaded alongside Tailwind
-lib/
-  song.py              Core data models (Note, Chord, Arrangement, Song)
-  sloppak.py           Sloppak format support
-  loosefolder.py       Loose-folder XML chart support
-  audio.py             OGG/MP3 audio handling
-  retune.py            Pitch-shifting logic
-  tunings.py           Tuning name/offset utilities
-  gp2rs.py             Guitar Pro to arrangement XML conversion
-  gp2midi.py           Guitar Pro to MIDI
-plugins/
-  __init__.py           Plugin discovery, loading, requirements install
-  <plugin_name>/        Each plugin is its own directory (often a git submodule)
-tests/
-  test_*.py             pytest test suite
-```
+## Claude-specific surfaces
 
-## Plugin System
+The rest of this file is content that *only* makes sense for Claude Code (other AI tools have their own incompatible automation mechanisms). Skills, subagent, rule, and settings live under [`.claude/`](.claude/):
 
-Plugins are the primary extension point. Each plugin lives in `plugins/<name>/` with a `plugin.json` manifest. Plugins are typically their own git repositories — see [CONTRIBUTING.md](CONTRIBUTING.md) for the licensing policy (curated plugins should be AGPL-3.0 or AGPL-compatible: MIT, BSD, Apache-2.0).
+- [`.claude/skills/plugin-scaffold/`](.claude/skills/plugin-scaffold/SKILL.md) - generates a plugin skeleton with capability-pipelines metadata.
+- [`.claude/skills/plugin-validate/`](.claude/skills/plugin-validate/SKILL.md) - validates `plugin.json` against `schema/plugin.schema.json` locally before push.
+- [`.claude/skills/speckit-*/`](.claude/skills/) - spec-kit skills (auto-generated from `.specify/`; don't edit manually).
+- [`.claude/rules/plugin-author.md`](.claude/rules/plugin-author.md) - glob-scoped to `plugins/**`; encodes the contracts from `docs/PLUGIN_AUTHORING.md` so suggestions don't drift from them.
+- [`.claude/agents/slopsmith-reviewer.md`](.claude/agents/slopsmith-reviewer.md) - plugin-aware code-review subagent. Invoke with `@slopsmith-reviewer`.
+- [`.claude/settings.json`](.claude/settings.json) - repo defaults (no hooks enabled by default; commented opt-in example for `plugin.json` validation on save).
 
-```json
-{
-  "id": "my_plugin",
-  "name": "My Plugin",
-  "version": "1.0.0",
-  "private": false,
-  "type": "visualization",
-  "nav": { "label": "My Plugin", "screen": "plugin-my_plugin" },
-  "screen": "screen.html",
-  "script": "screen.js",
-  "styles": "assets/plugin.css",
-  "routes": "routes.py",
-  "settings": {
-    "html": "settings.html",
-    "server_files": ["my_plugin.db", "my_plugin_models/"]
-  },
-  "diagnostics": {
-    "server_files": ["my_plugin.diag.json"],
-    "callable": "diagnostics:collect"
-  }
-}
-```
+See [`.claude/README.md`](.claude/README.md) for conventions when adding more.
 
-All fields except `id` and `name` are optional. Plugins can have any combination of frontend (screen/script), backend (routes), and settings.
+## Why this file is short
 
-`version` and `private` are advisory metadata — the plugin loader does not currently consume them, but plugins commonly include them for publishing/tooling purposes.
-
-`description`, `category`, and `icon` are **optional, additive v3 Pedalboard metadata** (surfaced in `/api/plugins`, consumed by the v3 Plugins page `static/v3/plugins-page.js`). `description` is a short one-sentence summary shown under the pedal name. `category` (`audio | creation | practice | game | tools`, free-form; unknown/absent → curated default → `"other"`) picks which pedalboard the plugin sits on. `icon` is an assets-relative thumbnail path (e.g. `"assets/thumb.png"`, ~square ~256×256, same containment rule as `styles`, served via `/api/plugins/<id>/assets/...`); if omitted the loader auto-detects `assets/thumb.png`, and plugins with no thumbnail get a default pedal graphic. All three are backward-compatible — omit them and the plugin still loads. See [docs/plugin-v3-ui.md](docs/plugin-v3-ui.md).
-
-`styles` is the **opt-in** for self-hosted CSS (Principle II — prebuilt Tailwind, no Play CDN). Core's `static/tailwind.min.css` only contains classes scanned from core source at build time, so a plugin installed at runtime (community / NAS) that uses classes core didn't scan — especially arbitrary values like `text-[11px]` — renders unstyled. Declaring `styles` makes the frontend inject one versioned `<link rel="stylesheet">` into `<head>` (covering the plugin's screen *and* its settings panel) pointing at the plugin's own compiled stylesheet. The value is a **plugin-root-relative path that must live under `assets/`** (e.g. `"assets/plugin.css"`) so it serves through the sandboxed `/api/plugins/<id>/assets/...` route. Build it with `corePlugins: { preflight: false }` (utilities only — core ships the single base reset; don't duplicate it) and **never** the Tailwind Play CDN. Plugins that use only core-guaranteed utilities, or ship no Tailwind, omit `styles` and are byte-for-byte unaffected. Full authoring guide + scaffold: [docs/plugin-styles.md](docs/plugin-styles.md).
-
-`settings.server_files` is the **opt-in** for the unified Settings export/import flow (feedBack#113). It's a list of relpaths under `context["config_dir"]` that the plugin wants included in user-triggered backups. A trailing `/` denotes a directory (recurse). Plugins that omit this field have no server-side files exported; their state lives entirely in browser `localStorage`, which is bundled wholesale on every export. Rules:
-- Relpaths only. Absolute paths, drive letters, `..` segments, and backslashes are rejected at load time with a `[Plugin]` warning.
-- The same allowlist is consulted at both export and import: a bundle that references a file the *importing host*'s manifest no longer declares is skipped with a warning (handles plugin updates between export and import). A bundle that references a file your host's manifest never declared is also skipped — no surprise writes.
-- Files are encoded as `{"encoding": "json", "data": <parsed>}` for `.json` files that parse cleanly (diff-friendly), `{"encoding": "base64", "data": "..."}` otherwise (sqlite, model blobs, IRs).
-- Plugins own their internal data migration. Importing a bundle whose data schema predates your current code restores bytes verbatim — your plugin must cope at next load.
-- Symlinks are skipped on export and never followed on import.
-
-`diagnostics` is the **opt-in** for the troubleshooting bundle (feedBack#166 — Settings → Export Diagnostics). Two independent fields:
-- `diagnostics.server_files` — same allowlist semantics as `settings.server_files`: relpaths under `context["config_dir"]`, no `..`, no abs paths, no backslashes, no leading dots. Files listed here are copied verbatim into `plugins/<plugin_id>/<relpath>` inside the bundle. Use this for snapshot-style state (small DB excerpts, model lists, last-error files).
-- `diagnostics.callable` — `"<module>:<function>"` (e.g. `"diagnostics:collect"`). Resolved lazily via `load_sibling` when the user clicks Export, then called as `func({"plugin_id": "...", "config_dir": Path(...)})`. Return `dict`/`list` → written to `plugins/<id>/callable.json`; `bytes` → `callable.bin`; `str` → `callable.txt`. Exceptions are caught and appended to the bundle's `manifest.notes` — a buggy plugin never crashes the export.
-
-Plugins that omit the field contribute nothing to the bundle from the backend side. Frontend plugins can independently push state via `window.feedBack.diagnostics.contribute(plugin_id, payload)` from their `screen.js` before the user hits Export. Bundle layout + per-file schemas: [docs/diagnostics-bundle-spec.md](docs/diagnostics-bundle-spec.md).
-
-Best practices:
-- Embed your own `schema` field (e.g. `"my_plugin.diag.v1"`) in JSON returned by `callable` so future tooling can dispatch by version.
-- Keep payloads small (< 100 KB). Diagnostics are not a backup channel — that's `settings.server_files`.
-- Don't include user secrets, API keys, or session tokens. The bundle is shared with maintainers / posted to GitHub issues.
-
-`type` is an optional role hint (feedBack#36). Supported values:
-- `"visualization"` — plugin provides a highway renderer. Declaring this makes the plugin eligible for the main-player viz picker AND splitscreen's per-panel picker. Must pair with a `window.feedBackViz_<id>` factory exporting the setRenderer contract below.
-- Absent → no declared role; plugin is loaded and its script runs, but it doesn't appear in role-specific UIs.
-
-**Backend routes** — `routes.py` must export a `setup(app, context)` function. The `context` dict provides:
-- `config_dir` — persistent config path
-- `get_dlc_dir()` — returns the DLC folder Path
-- `extract_meta()` — metadata extraction callable
-- `meta_db` — shared MetadataDB instance
-- `library_providers` — shared library provider registry for source-aware browsing
-- `register_library_provider(provider)` — register a plugin-provided library source. Providers expose `id`, `label`, optional `kind`/`capabilities`, and callable `query_page`, `query_artists`, `query_stats`, and `tuning_names` methods. Providers with `art.read` may also expose `get_art(song_id)` returning one of: a `Response` object (any media type, served as-is); raw `bytes` or `bytearray` (**assumed PNG** — use a `Response` or a `dict` with `content`+`media_type` keys for JPEG/WebP or other formats); a URL string (http/https → 302 redirect; other schemes are rejected with 400); a filesystem path string or `Path` (served as a file with auto-detected media type); or a `dict` with a `url`, `path`, or `content` key. Providers with `song.sync` may expose `sync_song(song_id)` returning `None` (success with no local file) or a `dict` — the dict is passed through as the JSON response and should include `filename`/`local_filename` if a local playable file was produced.
-- `unregister_library_provider(provider_id)` — remove a plugin-provided library source by id. The built-in `local` provider cannot be removed.
-- `get_sloppak_cache_dir()` — sloppak cache path
-- `load_sibling(name)` — loads a sibling module from this plugin's directory under a unique, namespaced module name. See "Sibling imports" below.
-- `log` — stdlib `logging.Logger` namespaced to `feedBack.plugin.<id>`. Pre-configured with the app-wide level, format (including JSON mode), and correlation IDs. Use this for all backend plugin output instead of `print()`. See "Backend plugin logging" below.
-
-**Sibling imports — use `load_sibling`, not bare imports** (feedBack#33). The plugin loader inserts each plugin's directory onto `sys.path` so `from extractor import X` works, but Python caches imports by **module name** in `sys.modules`. Two plugins that each ship a top-level `extractor.py` (or any other generic name — `util.py`, `client.py`, `parser.py`, `config.py`, …) collide: whichever loads first wins, and the other plugin's `from extractor import X` either gets the wrong module or fails with `cannot import name 'X' from 'extractor'`.
-
-The fix is `context["load_sibling"](name)`, which loads the sibling under a namespaced module name (`plugin_<id>.<name>`, where plugin_id is bijectively encoded so reverse-DNS-style ids like `com.example.foo` work without colliding: `_` -> `_5f_`, `.` -> `_2e_`) so each plugin gets its own copy:
-
-```python
-def setup(app, context):
-    helper = context["load_sibling"]("helper")
-    HelperClass = helper.HelperClass
-    # …
-```
-
-Notes:
-- `name` is a bare module name — no `.py` suffix, no slashes, no `.`. The helper raises `ValueError` for path traversal / format issues and `ImportError` for missing files.
-- Both single-file siblings (`extractor.py`) and package-form siblings (`extractor/__init__.py`) work. Package form wins when both exist (matches CPython's import-resolution precedence).
-- Relative imports between siblings work — `from .shared import X` in a top-level helper, `from ..shared import X` from inside a sibling package. The synthetic parent package `plugin_<id>` carries the plugin directory in its `__path__`.
-- `from . import sibling` (attribute-style) also resolves: loaded children are exposed as attributes on the parent package.
-- Repeat calls return the cached module. Concurrent first-time calls are serialized via per-module locks so no caller observes a half-initialized module.
-- Bare `import sibling` from `routes.py` still works during the transition period, but the loader prints a startup warning when it detects two plugins shipping a same-named top-level module — covering both `.py` files and package directories. Migrate to `load_sibling` to silence the warning and immunize your plugin from future ecosystem collisions. (Don't mix bare imports and `load_sibling` for the same module — they'd execute the file twice and split module-level state.)
-
-**Frontend scripts** — `screen.js` runs in the global scope via a `<script>` tag. It can access `window.playSong`, `window.showScreen`, `window.createHighway`, the `<audio>` element, and the `window.feedBack` event emitter.
-
-**The playSong wrapper chain** — Plugins commonly wrap `window.playSong` to hook into song playback. Plugins load alphabetically, so the last-loaded (alphabetically later) wrapper runs first, while the alphabetically first plugin runs closest to the original. Be aware that `await` calls in inner wrappers yield to the event loop — WebSocket messages can arrive before outer wrappers finish setup.
-
-## Plugin Best Practices
-
-### v3 UI (fee[dB]ack v0.3.0) — player-chrome contract
-
-v0.3.0 ships a redesigned UI behind a flag (`FEEDBACK_UI=v3` or the `/v3` route);
-the classic UI (v2) stays the default until 0.3.0 ships, so **plugins must work in
-both**. v3 reuses the same engine (`server.py`, `app.js`, `highway.js`, `playSong`,
-`showScreen`, capabilities, library providers, the `window.feedBackViz_<id>` /
-`setRenderer` contract), so a plugin's **backend, capabilities, `nav`/`screen`,
-visualization renderers, diagnostics, and settings export work unchanged** — v3
-surfaces `nav` in its sidebar and mounts screens exactly as v2 does.
-
-**The only thing that changed is the player chrome.** If your plugin injects a
-control into it, you must adapt:
-
-- v2's wide always-visible `#player-controls` bar is, in v3, a **minimal
-  auto-hiding transport** (fades ~2.5 s after the pointer stills during playback)
-  plus a hover-reveal left icon rail. So injecting into `#player-controls` the
-  legacy way means your control **auto-hides**, and the legacy insertion anchors
-  (`insertBefore` the `span.text-gray-700` separator, or `button:last-child` / ✕
-  Close) **don't exist in v3** → it lands wrong / unreachable.
-- **Detect v3** with `window.feedBack.uiVersion === 'v3'` and **mount into
-  `window.feedBack.ui.playerControlSlot()`** (a stable, always-reachable container
-  — the "Plugins" rail popover) instead of `#player-controls`. Drop the dead
-  anchors (append), and guard re-injection against the *actual* container
-  (`controls.contains(myBtn)`), not a hard-coded `#player-controls`.
-- A host `MutationObserver` re-homes legacy `#player-controls` children into the
-  slot as a fallback, but it **breaks plugins that guard on
-  `#player-controls.contains()`** (the moved node fails the check → re-inject every
-  song). Mount into the slot yourself; don't rely on the shim.
-- v3 uses `fb-*` tokens (`fb-card`, `fb-text`, `fb-textDim`, `fb-primary`,
-  `fb-border`) vs v2's `dark-*`/`accent`; legacy classes still render acceptably.
-  Keep `#player` overlay `z-index` ≤ the chrome layers (transport/HUD 20, rail 30,
-  popovers 40).
-
-Full guide + the canonical snippet: **[docs/plugin-v3-ui.md](docs/plugin-v3-ui.md)**.
-Verify any player-injecting plugin in **both** `/` (v2) and `/v3`.
-
-### Performance — never run DOM queries on a per-frame path
-
-Plugins share the main thread with the highway's 60 fps render loop, and during
-playback the highway + note detectors mutate the DOM ~60×/s — so anything that
-*reacts* to DOM changes runs that often too. Work that looks cheap in isolation
-becomes the dominant cost when it runs every frame. A profiled "the 3D highway is
-laggy" report turned out to be **three plugins doing per-frame `querySelectorAll`**
-(~18% of main-thread CPU + NodeList GC churn), not the renderer. The GPU was idle.
-
-- **Never call `querySelector` / `querySelectorAll` inside `draw()`, a
-  `requestAnimationFrame` loop, a short `setInterval`, or a `MutationObserver`
-  callback.** Resolve the element(s) **once** when your UI mounts and cache the
-  references; re-resolve only when the cached node is gone (`!el.isConnected`).
-  `querySelectorAll` also allocates a fresh `NodeList` every call → GC pressure at
-  60 fps. (notedetect #75 — a VU meter that `querySelector`'d its bar every tick.)
-
-- **Scope `MutationObserver`s narrowly — never `observe(document.body, { subtree:
-  true })` just to notice your own UI's container mount.** A body-subtree observer
-  fires on *every* DOM mutation anywhere, including the per-frame highway churn, so
-  a callback that then scans the document is a per-frame full-DOM scan. Observe the
-  specific container; if it's swapped on screen changes, observe a stable parent,
-  or **cheaply early-bail** (one `getElementById` / a screen-state check) *before*
-  the expensive work. (sloppak-converter #32 — a body-subtree observer re-ran
-  whole-document inject sweeps on every frame of playback.)
-
-- **Stop playback-tied loops when their UI is hidden.** An rAF/interval meter (VU,
-  etc.) that keeps drawing while its panel is closed is pure waste — gate it on
-  visibility, or stop and restart it on open/close.
-
-- **Per-instance, not global.** Under splitscreen a viz/detector plugin runs
-  multiple instances. Cache refs and resolve panels against your *own* instance's
-  container, never a global `document.querySelector` that could grab a sibling
-  instance's node. (notedetect #75 follow-up.)
-
-These are cheap to get right up front and expensive to retrofit. Profile the
-**main thread**, not the GPU, when a renderer "feels laggy" — the offender is
-usually an unrelated plugin's per-frame DOM work.
-
-### Visualization plugins — two complementary contracts
-
-FeedBack supports two ways for a plugin to participate in the main player's visuals. They coexist; the setRenderer contract is the default for any viz that draws a highway-shaped surface, and overlays handle layered decorations on top.
-
-**Pick the right shape:**
-- Replacing the whole highway drawing on the existing highway canvas (your renderer owns its rendering context / resources; `createHighway()` still owns the canvas element and the rAF loop)? → **setRenderer** (section 1). Enters the viz picker. Works in both the main player and per-panel under splitscreen.
-- Adding a layer on top of whichever viz is active? → **Overlay** (section 2). Navbar toggle, not in the picker.
-
-#### 1. setRenderer contract (feedBack#36) — preferred
-
-Plugins that want to replace the main highway's draw function (per panel, per session) export a renderer factory on `window.feedBackViz_<id>` where `<id>` matches the `id` in `plugin.json` (`type: "visualization"` required). The factory returns an object matching this shape:
-
-```js
-window.feedBackViz_my_viz = function () {
-    return {
-        // Required canvas context type. Default '2d' if omitted.
-        // highway.js reads this BEFORE calling init() so it can
-        // replace the underlying <canvas> element if the current
-        // one is locked to a different context type (see "Canvas
-        // context-type swapping" below).
-        contextType: '2d', // or 'webgl2'
-        init(canvas, bundle) {
-            // One-time setup. Own your getContext() call here —
-            // acquire '2d' or 'webgl2' depending on the renderer.
-            // The canvas you receive is guaranteed to either be
-            // unbound or already bound to your declared contextType.
-            this.ctx = canvas.getContext('2d');
-        },
-        draw(bundle) {
-            // Called each requestAnimationFrame tick by the factory.
-            // `bundle` is a snapshot with: currentTime, songInfo, isReady,
-            // notes, chords, anchors (all difficulty-filter-aware),
-            // beats, sections, chordTemplates, stringCount, lyrics,
-            // toneChanges, toneBase, mastery, hasPhraseData, inverted,
-            // lefty, renderScale, lyricsVisible, the 2D coordinate
-            // helpers project and fretX, and getNoteState (see below).
-            // `stringCount` is the active arrangement's string count (4
-            // for bass, 6 for guitar, 7+ for extended-range GP imports —
-            // size string-indexed geometry against this, not a hardcoded
-            // 6). If your renderer needs lefty-aware text rendering, check
-            // bundle.lefty and apply the mirror transform yourself —
-            // a bundle-level helper isn't provided because it would
-            // need your renderer's own context, not the factory's.
-            //
-            // bundle.getNoteState(note, chartTime) (feedBack#254) — call
-            // this per visible chart note / chord-note to find out whether
-            // a scorer (note_detect) has flagged it 'hit' / 'active' (a
-            // sustain currently being held correctly) / 'miss', so the gem
-            // itself can light up / a held sustain can glow instead of
-            // relying on an overlay ring. Returns null when no provider is
-            // registered or it reports nothing for this note; otherwise
-            // { state: 'hit'|'active'|'miss', alpha: 0..1, color: string|null }.
-            // For chord notes pass the chord's time (note_detect keys its
-            // judgments by `${time}_${string}_${fret}`). 'hit' and 'active'
-            // are both "lit" — a renderer may treat them identically; the
-            // provider owns all fade timing via `alpha` and by simply
-            // ceasing to return state when the effect should end.
-        },
-        resize(w, h) {
-            // Optional. Canvas dims already updated; re-create WebGL
-            // framebuffers / reset 2D transforms here.
-        },
-        destroy() {
-            // Optional. Release resources, remove DOM nodes, null refs.
-            // Called before setRenderer() swaps to another renderer
-            // and on highway.stop().
-        },
-    };
-};
-```
-
-Selecting this plugin in the main-player viz picker — or in splitscreen's per-panel picker — calls `highway.setRenderer(factory())` on the existing highway instance. The built-in 2D highway is the default renderer and is restored by passing nullish — `setRenderer(null)` and `setRenderer(undefined)` both work (the implementation gates on `r == null`). Splitscreen panels create one `createHighway()` per panel and each independently consults the picker, so N panels can run different renderers (or N copies of the same renderer with different arrangements) without coordination.
-
-**Lifecycle contract.** The factory returns a single renderer instance that may go through multiple `init() → ... → destroy()` cycles as the user navigates between songs or screens. Specifically:
-
-- `init(canvas, bundle)` runs when the highway has a canvas and the renderer takes over drawing. This is when to acquire `getContext()`, build shaders / meshes / DOM nodes, and register listeners.
-- `draw(bundle)` runs on every rAF frame once the WebSocket `ready` message has fired and until the renderer is replaced or the highway stops. It is **not** called during the loading / reconnect window (between `api.init()` + `stop()` and the next `ready`) — that would hand the renderer half-populated chart arrays. Renderers that want to show a "loading" state can read `bundle.isReady` inside a future-widened contract, but today the factory gates `draw` behind the ready flag and `isReady` is only informational once it does fire.
-- `destroy()` runs when the renderer is replaced via another `setRenderer(...)` call, OR when `highway.stop()` is called (e.g. the user navigates away from the player). It releases everything `init()` acquired.
-- **After `destroy()`, the same instance may receive another `init()` call** — this happens on `playSong()` which does `stop()` → `init()` to reuse the same canvas element for the next song. Renderers must tolerate `init()` being called again on an instance that was previously destroyed. Practically: null your refs in destroy, re-acquire them in init.
-- `destroy()` is skipped when it would run on an un-init'd renderer — if a caller does `setRenderer(x)` before the highway ever init'd (possible when restoring a saved picker selection at page load), `x.destroy()` is not called until `x.init()` has run at least once.
-- `resize(w, h)` is optional; runs after init and whenever the canvas dimensions change.
-
-**Key rules:**
-- The factory **returns a fresh object on each call** — important for splitscreen, where multiple panels will each get an independent instance.
-- The renderer **owns its own rendering context** (2D or WebGL). Factory will not call getContext for you.
-- **Canvas context-type swapping.** Browsers lock a `<canvas>` to the first context type successfully acquired for its lifetime: once `getContext('2d')` succeeds, `getContext('webgl2')` on that same canvas returns `null`, and vice versa. To let arbitrary 2D ⇄ WebGL renderer swaps work mid-session, `highway.setRenderer()` reads the next renderer's `contextType` before calling its `init()` and, if it differs from the type currently bound, replaces the underlying `<canvas>` element with a fresh one via `oldCanvas.cloneNode(false)` followed by `oldCanvas.replaceWith(newCanvas)`. The factory then calls the renderer's `init(newCanvas, bundle)` with the fresh element so its `getContext()` succeeds. Practical implications:
-  - **What survives the swap.** `cloneNode(false)` preserves *every HTML attribute* on the element — `id`, `class`, inline `style`, all `data-*` and `aria-*` attributes, `role`, `tabindex`, the attribute form of `width`/`height`, and anything else a plugin attached. DOM position is preserved by `replaceWith()`, so siblings, parents, and surrounding layout are unaffected.
-  - **What does NOT survive.** Event listeners attached via `addEventListener` are NOT cloned, and expando properties set imperatively on the JavaScript object (such as the bound rendering context, or any `canvas._myPlugin = …`-style data a plugin attached) are not carried over either. The bound rendering context being left behind on the detached element is exactly what allows the new canvas to start fresh and accept a different `getContext()` call. Note: `canvas.width`/`canvas.height` *are* reflected HTML attributes, so those values do survive the clone; `api.resize()` re-applies the backing-store dimensions on the new element after the swap regardless.
-  - Renderers must **declare `contextType`** on the returned instance (`'2d'` or `'webgl2'`; absent → `'2d'`). Factories may also expose it as a static (`window.feedBackViz_<id>.contextType = 'webgl2'`) so core can read it before constructing the renderer — used today by Auto-mode evaluation.
-  - Plugins that hold a stale reference to the highway canvas across renderer swaps — including any code that registered listeners directly on the canvas element rather than on `window`/`document` — should listen for the `highway:canvas-replaced` event on `window.feedBack` and re-acquire / re-register. `window.feedBack.emit` dispatches a `CustomEvent`, so the payload `{ oldCanvas, newCanvas, contextType }` lives on `event.detail`, not on the event object itself:
-    ```js
-    window.feedBack.on('highway:canvas-replaced', (event) => {
-        const { oldCanvas, newCanvas, contextType } = event.detail;
-        // re-acquire / re-register against newCanvas
-    });
-    ```
-    Plugins that re-query `document.getElementById('highway')` lazily inside their own event handlers don't need this listener — they pick up the new element automatically (it keeps `id="highway"`).
-  - **`highway:visibility`** — fired on `window.feedBack` whenever the highway canvas transitions between displayed and hidden. Detection is DOM-based via `canvas.offsetParent === null` (catches `display:none` on the canvas or any ancestor — e.g. splitscreen's `#highway` hide) or whatever a host explicitly sets via `highway.setVisible(bool)`. While `visible === false`, core skips the rAF `renderer.draw(bundle)` call AND the default 2D draw, so renderers don't have to no-op themselves. The event is emitted only on transitions (including the first one after `init()`), not every frame. Payload `{ visible, canvas }` lives on `event.detail`:
-    ```js
-    window.feedBack.on('highway:visibility', (event) => {
-        const { visible, canvas } = event.detail;
-        // Toggle any sibling DOM your renderer mounts. The 3D Highway
-        // renderer hides its `.h3d-wrap` overlay here so `display:none`
-        // on `#highway` actually hides the visible output.
-    });
-    ```
-    Renderers that only paint to the feedBack canvas don't need this listener — the rAF skip is enough. Renderers that mount sibling DOM (separate WebGL contexts, overlays, etc.) do.
-  - **`highway.setVisible(bool | null)`** — forces the visibility state regardless of `offsetParent`. Pass `null` to clear the override and resume DOM-based detection. Useful when the host hides the highway via `visibility:hidden`, `opacity:0`, transforms, or clipping rather than `display:none`. The override re-emits any resulting transition immediately rather than waiting for the next rAF tick.
-  - Default-renderer ctx is closure-cached. The replace path nulls the closure ctx so stale draw paths short-circuit; the next default-renderer `init()` re-acquires the 2D context from the new canvas cleanly.
-- `draw(bundle)` receives difficulty-filtered arrays — never read from `_filteredNotes` or other internals.
-- `_drawHooks` fire for the default 2D renderer (the factory calls them at the end of each frame). Custom WebGL renderers that maintain a 2D overlay canvas (like the bundled 3D highway) also call `window.highway.fireDrawHooks(ctx, W, H)` on that overlay so overlay plugins continue to work regardless of which renderer is active. Custom renderers without a 2D overlay context should not attempt to fire hooks.
-
-**Auto mode — `matchesArrangement(songInfo)` (optional).**
-
-The viz picker prepends an "Auto (match arrangement)" entry that is the default selection on fresh installs. When Auto is active, core evaluates registered viz factories on every `song:ready` and swaps the renderer to the first factory whose `matchesArrangement(songInfo)` predicate returns truthy. No match → the built-in 2D highway.
-
-Declare the predicate as a static on the factory (not the instance) so core can evaluate it without constructing a throwaway renderer:
-
-```js
-window.feedBackViz_piano = function () { /* ... */ };
-window.feedBackViz_piano.matchesArrangement = function (songInfo) {
-    return /keys|piano|synth/i.test((songInfo && songInfo.arrangement) || '');
-};
-```
-
-- `songInfo` is the highway's live song_info snapshot — `arrangement`, `tuning`, `capo`, `centOffset`, `arrangement_index`, `filename`, `artist`, `title`, etc. May be `{}` before the first song loads.
-- Factories without `matchesArrangement` are skipped during auto-selection — the correct default for arrangement-agnostic viz (tabview, jumpingtab) that only make sense as manual picks.
-- Explicit picker selections override Auto and are persisted to `localStorage.vizSelection`, so the pinned choice survives page reloads until the user switches back to "Auto" (which also persists). Picking "Auto" re-evaluates against the current song immediately. In contexts where `localStorage` is unavailable (private mode, sandboxed iframes, some test runners) persistence falls back to the current picker `<option>` value, which still overrides Auto for as long as the page stays loaded.
-- When an Auto-selected renderer fails and core emits `viz:reverted`, the picker falls back to the built-in default and disables auto-switching until the user re-selects Auto.
-- First match wins (picker order), so the registration order of plugins is the tiebreaker. Keep predicates narrow to avoid stealing songs from more specialized viz.
-
-**WebGL viz in Auto mode.** Auto evaluation runs on every `song:ready` regardless of which renderer is active. Auto-installing a WebGL renderer when the canvas is currently 2D — or reverting from a WebGL Auto pick to the default 2D — works without a reload because `setRenderer` swaps the canvas element when `contextType` differs (see "Canvas context-type swapping" above). WebGL viz can therefore safely declare `matchesArrangement` and rely on Auto. For 3D Highway specifically, `_canRun3D()` in app.js still gates Auto from picking it on machines without WebGL2 — that fallback is independent of canvas swapping.
-
-**Per-instance settings for host plugins (feedBack#849).** A viz provider may declare per-instance controls a consuming host (e.g. splitscreen's per-panel popover) renders generically, by adding a `settings` array to its `capabilities.visualization` manifest block: `[{ key, label, type: "toggle" | "range" | "select", default, min?, max?, step?, options? }]`. This is the capability-native, declarative replacement for the ad-hoc `factory.panelControls` static. The validated list is surfaced through the visualization host's `list-providers` snapshot, so a host reads it without knowing the plugin. **A provider that declares `settings` MUST implement `applySetting(key, value)` on its renderer instance** — the host calls it on the specific per-panel instance, which is inherently per-panel (no canvas→panel resolution, no shared global localStorage keys). `getSetting(key)` is optional (the host falls back to the declared `default`); the host owns persistence. `factory.panelControls` remains read as a legacy fallback for hosts that still consume it, but new viz should declare `settings` + `applySetting`.
-
-#### 2. Overlay contract — for add-on layers
-
-Plugins that add a layer on top of whichever visualization is active — HUDs, fretboard diagrams, chord labels, practice feedback — don't replace the renderer. They manage their own canvas, their own rAF loop, and a toggle button somewhere visible (typically a navbar pill), reading public highway state via the getters:
-
-- `highway.getTime()` / `highway.getBeats()` — current playback position
-- `highway.getNotes()` / `highway.getChords()` — raw arrays containing every note/chord in the chart regardless of the current difficulty level
-- `highway.getFilteredNotes()` / `highway.getFilteredChords()` — difficulty-filtered variants. Returns the master-difficulty-filtered arrays when the song has phrase-level data (slider active); falls through to the raw arrays for songs with a single difficulty level (slider disabled). Plugins that process only the notes the player is currently expected to play should use these instead of `getNotes()` / `getChords()`
-- `highway.hasPhraseData()` — returns `true` when the current song has phrase-level difficulty ladder data (i.e. the mastery slider is active and `getFilteredNotes()` / `getFilteredChords()` return a filtered subset). Use this to gate logic that only makes sense when difficulty filtering is available
-- `highway.getPhrases()` — phrase timing windows `[{ index, start_time, end_time, max_difficulty }]` for the current song's difficulty ladder. Returns `null` when phrase data is absent (GP imports, single-difficulty charts). Read-only; do not mutate. Pair with `hasPhraseData()` to gate phrase-aware logic.
-- `highway.getMastery()` — current master-difficulty slider value as a fraction `0..1`. Reflects the same value the mastery slider is set to; meaningful only when `hasPhraseData()` is true.
-- `highway.getChordTemplates()` — chord shape lookup table; index by `chord.id` from `getChords()` to get `{ name, fingers, frets }`. `fingers` and `frets` are per-string arrays (length matches the tuning's string count); within `fingers`, `-1` = unused, `0` = open string, `n > 0` = finger number. arrangement XML sources populate real fingerings; GP imports currently emit all `-1` since pre-import sources don't carry finger data. Not filter-aware: templates are static metadata, every `chord_id` referenced by `getChords()` is guaranteed valid
-- `highway.getSongInfo()` — tuning, arrangement, capo
-- `highway.getStringCount()` — number of strings on the active arrangement (4 for bass, 6 for guitar, 7+ for extended-range GP imports). Derived server-side as `max(notes-max-string + 1, name-based fallback, len(tuning))` where the tuning length only contributes when it isn't the arrangement XML padded 6-string form (sloppak / GP-imported sources carry trimmed tuning lengths). The name-based fallback is 4 for arrangements containing "bass" (case-insensitive) and 6 otherwise. This combination handles partial-string-usage charts (a 6-string lead that never plays string 5), extended-range GP imports (5-string bass, 7-string guitar), and sloppaks that explicitly encode the instrument range — without requiring plugins to do their own arrangement-name matching
-- `highway.getLefty()` / `highway.getInverted()` — mirror + invert state
-
-Overlays do NOT appear in the viz picker and do NOT declare `"type": "visualization"` in `plugin.json`. They coexist with whichever renderer (default 2D, 3D highway, piano, ...) the user has picked.
-
-**Key rules:**
-- **Own your rAF + canvas** — don't piggyback on `_drawHooks` or on `createHighway`'s rendering context. Draw hooks fire for the default 2D renderer and for custom renderers that explicitly call `window.highway.fireDrawHooks(ctx, W, H)` (e.g. the bundled 3D highway fires them on its 2D overlay canvas), but not for every custom renderer.
-- **Re-read state every frame** — overlay output must track whatever the current renderer is drawing. Don't cache note positions across frames.
-- **Respect lefty + invert toggles** — if the overlay depicts strings or frets, mirror using the same transforms the active renderer would.
-- **If you position with `highway.project` / `highway.fretX` (the 2D-highway geometry), gate on `highway.isDefaultRenderer()`** — those helpers describe the *built-in 2D* highway's depth curve and fret zoom. When a custom renderer (3D highway, piano, …) is active your draw hook still fires (on that renderer's 2D overlay layer), but those coordinates won't match its scene — markers land in arbitrary places. Skip rendering when `isDefaultRenderer()` is false; the custom renderer owns that feedback. Renderer-agnostic overlays (fretboard diagram, chord-label HUD — they use `getNotes()`/`getChordTemplates()` + their own layout) don't need this guard.
-- **Clean up on toggle-off** — cancel rAF and remove/hide the overlay canvas so inactive overlays aren't wasting frames.
-
-Reference: [fretboard plugin](https://github.com/got-feedback/feedBack-plugin-fretboard) — canonical overlay implementation (navbar toggle, own canvas, 80ms active-note window).
-
-**Why two?** setRenderer plugs into an existing highway — main-player or splitscreen-panel — reusing its WebSocket and data parsing, so the common "I want a different look for the same data" case is zero boilerplate AND multi-instance for free. Overlays compose with whatever renderer is active — they decorate rather than replace, so multiple can stack (fretboard + chord labels + practice feedback) without fighting over the canvas.
-
-A previous standalone-pane contract (`window.createMyVisualization({ container })` with its own WebSocket per pane) was used by splitscreen pre-Wave-C. It's been retired now that splitscreen calls `setRenderer` on per-panel `createHighway()` instances; if you find references in older plugin docs or external integration guides, those describe the legacy path.
-
-#### 3. Note-state provider — for scorers that want renderers to "light up" notes (feedBack#254)
-
-A scoring plugin (note_detect) can publish a per-note judgment so whichever renderer is active draws the **gem itself** lit on a correct hit, and keeps a sustain trail glowing while it's still being played correctly — instead of a separate overlay ring floating near the note.
-
-```js
-// In the plugin (after resolving the highway instance):
-highway.setNoteStateProvider((note, chartTime) => {
-    // `note` is the chart note object ({ t, s, f, sus, ... }); for chord
-    // notes `chartTime` is the chord's time. Return one of:
-    //   - falsy  → no special state (render normally)
-    //   - 'hit'    — struck correctly; renderer lights the gem
-    //   - 'active' — a sustained note is right now being held correctly
-    //   - 'miss'   — missed; renderer may red-wash the gem
-    //   - { state: <one of the above>, alpha?: 0..1, color?: '#rrggbb' }
-    // You own all fade timing: return a decaying `alpha` for a struck-note
-    // glow, `alpha: 1` (or a bare string) for a held sustain, and stop
-    // returning state when the effect should end. Keep it cheap — it's
-    // called per visible note per renderer per frame.
-});
-// On teardown:  highway.setNoteStateProvider(null);
-```
-
-- Only one provider is active at a time (last `setNoteStateProvider` wins). `highway.getNoteStateProvider()` returns the current one (or null).
-- The built-in 2D highway consults it in `drawNote` / `drawSustains` / the chord-frame path: 'hit'/'active' → bright string colour + additive halo + a contained "sizzle" (crackling sparks, throbbing core, a shockwave ring on a fresh strike) on the gem and a bright (vs dim) sustain trail; 'miss' → faint red wash. The bundled **3D highway** reads the same data via `bundle.getNoteState` (bright string-tinted outline + bright body + glowing sustain + a contained sparkle hugging the note rect on hit/active; red outline + suppressed body on miss). Custom renderers that want it call `bundle.getNoteState(note, chartTime)` — it null-guards and returns the normalized `{ state, alpha, color }` (or null).
-- This is orthogonal to the overlay contract: note_detect remains an overlay (HUD, diagnostic miss markers, the "currently detected" indicator) *and* a scorer that feeds this provider. A renderer that ignores `getNoteState` simply doesn't light gems — nothing breaks.
-
-### Audio mixer fader registration (feedBack#87)
-
-Plugins that produce audio outside the song's `<audio>` element (NAM amp output, synth voices, etc.) can register a labeled fader so users can balance them against the song from one mixer popover in the player controls.
-
-```js
-function _registerFader() {
-    const api = window.feedBack && window.feedBack.audio;
-    if (!api) return;
-    api.registerFader({
-        id: 'my_plugin',           // unique key
-        label: 'My Plugin',        // shown above the fader
-        unit: 'dB',                // optional suffix shown next to the value (e.g. '%', 'dB')
-        min: 0, max: 2, step: 0.05,
-        defaultValue: 1.0,
-        getValue: () => _myCurrentVolume,        // read current value
-        setValue: (v) => _setMyVolume(v),         // write + persist + apply
-    });
-}
-
-if (window.feedBack && window.feedBack.audio) {
-    _registerFader();
-} else {
-    window.addEventListener('feedBack:audio:ready', _registerFader, { once: true });
-}
-```
-
-The plugin owns persistence — the registry calls `getValue()` when the popover opens, and also after each `setValue()` during slider drags to re-sync the displayed value. Keep `getValue()` cheap and side-effect-free, and make sure `setValue()` updates whatever backing state `getValue()` reads synchronously. Pair `setValue` with whatever your plugin already does internally (write the GainNode, persist to localStorage, update any in-plugin label). Use `unregisterFader(id)` when your plugin is teardown-able and you want the strip to disappear; otherwise keep it registered so the user's setting persists across toggle states.
-
-### Backend plugin logging
-
-Use `context["log"]` for all backend plugin output. It is a stdlib `logging.Logger` namespaced to `feedBack.plugin.<id>`, pre-configured with the app-wide level, format (including JSON mode), and correlation IDs. Never use `print()` — it bypasses correlation context and log rotation.
-
-```python
-def setup(app, context):
-    log = context["log"]
-    log.info("plugin ready")
-    log.warning("optional dependency %r not found, feature disabled", dep)
-    try:
-        risky_init()
-    except Exception:
-        log.exception("unhandled error during setup")  # auto-captures traceback
-```
-
-For CLI entry points (scripts that also run as `__main__`), add a stdlib fallback so the logger works without the server pipeline:
-
-```python
-if __name__ == "__main__":
-    import logging
-    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
-```
-
-### Diagnostics contribution from frontend (feedBack#166)
-
-Plugins that hold useful debug state in the browser (active model name, last user input, internal counters) can push it into the diagnostics bundle by calling `window.feedBack.diagnostics.contribute(plugin_id, payload)` at any time. The contribution API is idempotent — repeated calls overwrite the previous value. Whatever was last contributed before the user hits Export Diagnostics is what lands in `plugins/<plugin_id>/client.json`.
-
-```js
-window.feedBack.diagnostics.contribute('my_plugin', {
-    schema: 'my_plugin.client_diag.v1',
-    active_preset: getActivePreset(),
-    last_error: _lastError,
-});
-```
-
-Loaded from `static/diagnostics.js` ASAP in `<head>` so the console-wrap is in place before any other script runs. Available on the `window.feedBack.diagnostics` namespace alongside `snapshotConsole()`, `snapshotHardware()`, `snapshotUa()`, `snapshotLocalStorage()`, `snapshotContributions()`. Keep your payload small (< 100 KB) and don't include secrets — bundles are shared with maintainers.
-
-### Keyboard Shortcuts
-
-Plugins can register keyboard shortcuts via the global `window.registerShortcut()` function. Shortcuts appear in the `?` help panel.
-
-```js
-window.registerShortcut({
-    key: 'k',                       // key value (e.key) or key code (e.code)
-    description: 'Toggle my view',  // shown in the help panel
-    scope: 'player',                // 'global' | 'player' | 'library' | 'settings' | 'plugin-{id}'
-    condition: () => _isMyViewActive, // optional guard
-    handler: (e) => _myAction()      // called when shortcut triggers
-});
-```
-
-**Scope** controls when the shortcut is active:
-- `global` — works on any screen
-- `player` — only on the player screen
-- `library` — only on the home/favorites screens
-- `settings` — only on the settings screen
-- `plugin-{id}` — only when your plugin's screen is active
-
-**Panel-scoped shortcuts:** For plugins that create multiple panels (e.g., splitscreen), shortcuts are automatically scoped to the active panel. Use `const panel = window.createShortcutPanel(id)` to create a panel (it returns the panel object — keep the reference so you can call `panel.clearShortcuts()` during cleanup) and `window.setActiveShortcutPanel(id)` to switch between them. Each panel has its own shortcut registry, so multiple panels can have the same key without collisions.
-
-**Condition** is an optional guard function. If it returns false, the shortcut is skipped even if in scope.
-
-**Key matching:** The handler matches against both `e.key` (character produced) and `e.code` (physical key). Use `e.key` for letters/symbols that depend on keyboard layout, and `e.code` for special keys (e.g. `Space`, `ArrowLeft`).
-
-**Built-in shortcuts:**
-
-| Key | Description |
-|-----|-------------|
-| `?` | Show keyboard shortcuts panel (global) |
-| `Space` | Play/Pause (player only) |
-| `←` / `→` | Seek ±5 seconds (player only) |
-| `Escape` | Back to library (player only) |
-| `[` / `]` | Audio offset ±10ms (Shift: ±50ms) (player only) |
-
-**Debugging:** Open browser console and type `_listShortcuts()` to inspect registered shortcuts.
-
-### General plugin guidelines
-
-- Wrap your plugin code in an IIFE: `(function () { 'use strict'; ... })();`
-- Use `localStorage` for user-facing settings, prefixed with your plugin id
-- If hooking `window.playSong`, always call the original and `await` it
-- If hooking `window.showScreen`, clean up your state when leaving the player screen
-- Use `window.feedBack.emit()` / `window.feedBack.on()` for inter-plugin communication
-- Use `window.registerShortcut()` to add keyboard shortcuts. Clean up with `window.unregisterShortcut(key, scope)` — pass the same scope you registered with, since the default is `'global'` and won't match `player`/`library`/`settings`/`plugin-*` bindings. For panel-scoped shortcuts, prefer `panel.clearShortcuts()`.
-
-## Song Formats
-
-FeedBack supports two song formats:
-
-### Loose folder (XML charts)
-A directory containing arrangement XML plus an audio file (and optional `manifest.json` + album art). Discovered, indexed, and played directly — see `lib/loosefolder.py`. Metadata follows a `manifest.json` → XML tags → folder-name priority chain. Songs are tagged `format: "loose"` in the library.
-
-### Sloppak (open format)
-An open, hand-editable song package designed for FeedBack. Exists in two interchangeable forms:
-- **Zip archive** (`.sloppak` file) — distribution form
-- **Directory** (`.sloppak/` folder) — authoring form
-
-**Contents:**
-```
-manifest.yaml          Song metadata (title, artist, album, duration, tuning, arrangement IDs, ...)
-arrangements/
-  lead.json            Note/chord/anchor data in wire format (see song.py)
-  rhythm.json          Files here are driven by manifest.yaml arrangement entries
-  ...                  (e.g. arrangements/<arrangement-id>.json)
-stems/
-  full.ogg             Mixed audio (always present)
-  guitar.ogg           Individual stems (optional, from Demucs split)
-  bass.ogg
-  drums.ogg
-  vocals.ogg
-  piano.ogg
-  other.ogg
-cover.jpg              Album art (optional)
-lyrics.json            Syllable-level lyrics (optional)
-```
-
-Sloppak is the preferred format for new features. The [Stems plugin](https://github.com/topkoa/slopsmith-plugin-stems) provides live stem mixing for sloppak songs.
-
-**Full developer reference:** the authoritative format spec now lives in its own repo —
-[got-feedback/feedpak-spec](https://github.com/got-feedback/feedpak-spec)
-([`spec/feedpak-v1.md`](https://github.com/got-feedback/feedpak-spec/blob/main/spec/feedpak-v1.md)):
-manifest schema, arrangement wire format, and how to extend the format with new data types (drum
-tab, key/scale annotations, etc.). Published as **feedpak**; this codebase still uses the legacy
-**sloppak** name internally — same on-disk format. [docs/sloppak-spec.md](docs/sloppak-spec.md) is
-a local pointer + code map.
-
-**Key code:**
-- `lib/sloppak.py` — format detection, zip/directory resolution, metadata extraction, song loading
-- `lib/sloppak_convert.py` — sloppak assembly pipeline, Demucs stem splitting
-- `lib/song.py` — shared data models (`Note`, `Chord`, `Arrangement`, `Song`) and wire format serialization used by both formats
-
-## Frontend Conventions
-
-- **No frameworks** — vanilla JS, fetch API, DOM manipulation
-- **Globals** — `highway`, `audio`, `playSong()`, `showScreen()`, `createHighway()`, `window.feedBack`
-- **Storage** — `localStorage` for all user preferences
-- **Styling** — Tailwind CSS utility classes, dark theme (`bg-dark-600`, `text-gray-300`, accent `#4080e0`, gold `#e8c040`). Tailwind is served as a **prebuilt** stylesheet (`static/tailwind.min.css`, regenerated by `bash scripts/build-tailwind.sh`), **never** the runtime Play CDN — the CDN's on-the-fly JIT rescanned the DOM on the main thread and dropped ~26% of frames with the 3D highway (feedBack-desktop#110). The committed CSS only contains classes the build scanner saw, so CI (`tailwind-fresh`) rebuilds and diffs it; run the build script and commit when you add new classes. A plugin that uses classes not guaranteed in core (notably arbitrary values like `w-[37px]`) MUST ship its own compiled stylesheet via the `styles` manifest key, built with `corePlugins.preflight = false` (utilities only — core ships the one base reset). Plugins MUST NOT load the Tailwind Play CDN or any runtime CSS JIT. See constitution Principle II.
-- **Naming** — camelCase for JS functions, kebab-case for CSS classes, snake_case for plugin IDs
-- **Player layout** — `#player` is `display:flex; flex-direction:column; position:fixed; inset:0`. `#highway` is `flex:1`. `#player-controls` sits at the bottom. Hiding the highway collapses the layout — use `margin-top: auto` on controls if you need to hide it.
-
-## Backend Conventions
-
-- **Framework** — FastAPI with uvicorn
-- **Imports** — flat imports from `lib/` (no package `__init__.py`): `from song import Song`
-- **Database** — SQLite via MetadataDB class with `threading.Lock` for thread safety
-- **WebSocket** — JSON frames, try/except `WebSocketDisconnect`
-- **Error handling** — graceful fallbacks (audio conversion errors don't crash the song, missing art returns placeholder)
-- **Type hints** — used sparingly (`Path | None`, `dict`, `list`)
-- **Docstrings** — minimal; code is self-documenting
-
-## Testing
-
-```bash
-pytest                         # Run all tests
-pytest tests/test_song.py -v   # Specific file
-pytest -k "round_trip" -v      # Pattern match
-```
-
-- Framework: pytest
-- Config: `pyproject.toml` sets `pythonpath = [".", "lib"]` and `testpaths = ["tests"]`
-- CI: GitHub Actions runs pytest on push/PR to main (Python 3.12)
-- Test dependencies: `requirements-test.txt`
-
-## Tuning the note_detect plugin
-
-Detection quality is hard to judge by eye — a player UI that "feels worse" after a code change isn't a regression you can defend in review. The plugin ships with a record-replay-sweep workflow so changes to the detector, the matcher, or the user's environment (A/V offset, latency, channel) can be measured against a single reference take.
-
-Quick orientation:
-- **Reference recording** lives in the gear popover on the player (gated behind Settings → Note Detection → "Detection tuning (advanced)"). Arm before pressing Play; auto-saves a WAV to `static/note_detect_recordings/` on song-end. The directory is bind-mounted, so the host-side harness can read it without a copy step.
-- **Benchmark sloppak** ships in-tree at [docs/benchmarks/note_detect_v1/note_detect_benchmark_v1.sloppak](docs/benchmarks/note_detect_v1/note_detect_benchmark_v1.sloppak) — 8 sections each isolating a different failure mode (low-freq mono, sustained holds, hammer/pull, power chords, dense open chords, bends). Drop it directly into your sloppak DLC folder to install (don't rename — feedBack keys off the `.sloppak` suffix even though the file is a zip under the hood). The unzipped form lands at `static/sloppak_cache/note_detect_benchmark_v1.sloppak/` after first play. Builder: [docs/benchmarks/note_detect_v1/build_benchmark.py](docs/benchmarks/note_detect_v1/build_benchmark.py).
-- **Headless harness** at [`tools/harness.js`](https://github.com/got-feedback/feedBack-plugin-notedetect/blob/main/tools/harness.js) in the note_detect plugin's own repo (cloned into `plugins/note_detect/` locally) runs the same `processFrame` / `matchNotes` / `checkMisses` code path off Node, in seconds per run. Same `note_detect.diagnostic.v1` schema as the in-app Download Diagnostic button.
-- **A/V auto-calibrate** (Settings → Note Detection) reads `timing_error_ms_hits.median` and proposes the av-offset that drives it to zero. Iterative: usually converges in 2–3 Apply rounds.
-
-**Always record at 1.0× playback speed** — half-speed takes produce all-miss garbage because chart times are absolute. **Always use `timing_error_ms_hits` (not all-matched) as a calibration signal** — the all-matched median pins near a constant when the offset is wrong, because the matcher silently snaps to neighbouring chart notes.
-
-Full developer reference (workflow recipes, harness flag table, diagnostic schema, common pitfalls): [docs/note-detect-tuning.md](docs/note-detect-tuning.md).
-
-## Versioning
-
-- **`VERSION`** (repo root) — single source of truth; plain semver string (e.g. `0.2.4`). Bind-mounted into the container and copied by the Dockerfile so it's always available at `/app/VERSION`.
-- **`GET /api/version`** — returns `{"version": "<contents of VERSION>", "source_url": "...", "license_url": "..."}`. The version drives the navbar badge; `source_url` / `license_url` populate the Settings → About links. `source_url` is configurable via the `APP_SOURCE_URL` env var (default `https://github.com/got-feedback/feedBack`); `license_url` falls back to `source_url + "/blob/main/LICENSE"` (GitHub-style, default branch `main`) and is overridable via the `APP_LICENSE_URL` env var — set it explicitly when the source is hosted on a non-GitHub forge (GitLab/Gitea/self-hosted) or under a non-`main` default branch. Both env values must be `http(s)`; non-http(s) values are rejected and fall back to the safe default to prevent `javascript:`/`data:` hrefs.
-- **Auto-sync** — `.github/workflows/sync-version.yml` rewrites `VERSION` via a `repository_dispatch` (`desktop-released`) fired from `feedBack-desktop`'s release job. As an explicit automation-only exception to the "Never push directly to main" rule in Git Workflow below, the sync job commits straight to `main` as `github-actions[bot]` (version bumps are mechanical; the PR round-trip adds no signal). Human contributors must still go through feature branches + PRs. No manual VERSION edits needed. Use the workflow's `workflow_dispatch` trigger with `version: X.Y.Z` for manual runs (recovery / out-of-band bumps).
-- **`CHANGELOG.md`** — follows [Keep a Changelog](https://keepachangelog.com/) format. Update the `[Unreleased]` section with each PR; when `feedBack-desktop` cuts a release, rename `[Unreleased]` to the new version + date (the VERSION bump itself is automated).
-
-## Git Workflow
-
-- **Never push directly to main** — always create a feature branch and open a PR
-- **Upstream remote** — set `upstream` to the canonical FeedBack repository; `origin` is your fork
-- **Plugins are gitlinks** — each plugin in `plugins/` is typically its own git repo (submodule or clone). Branch switches on the main repo can clobber plugin directories. Use `git update-index --assume-unchanged` for plugin dirs if needed.
-- **Commit style** — short imperative subject line, blank line, then body explaining *why*
-
-## WebSocket Protocol Reference
-
-The highway WebSocket at `/ws/highway/{filename}?arrangement={index}` streams these messages in order:
-
-| Message | Shape | Description |
-|---------|-------|-------------|
-| `loading` | `{ type: 'loading', stage }` | Status/progress message during extraction or conversion |
-| `song_info` | `{ type, title, artist, arrangement, arrangement_index, arrangements, duration, tuning, capo, centOffset, format, audio_url, audio_error, stems }` | Song metadata. `arrangements` is the full list for the switcher. `audio_url` is `null` when audio is unavailable, in which case `audio_error` is non-null; otherwise `audio_error` is `null`. `stems` is always present — an empty array for non-sloppak songs or sloppak songs with no split stems. `tuning` is an array (6 for guitar, 4 for bass). `centOffset` is a float (cents) from the RS2014 `<centOffset>` field — commonly `-1200.0` for extended-range bass (one octave down), small non-zero values for true-tuned content (e.g. A443 ≈ +11.8 cents), `0.0` when absent. Available via `getSongInfo().centOffset`. |
-| `beats` | `{ type, data: [{ time, measure }] }` | Beat timestamps with measure numbers |
-| `sections` | `{ type, data: [{ time, name }] }` | Named sections (Intro, Verse, Chorus, etc.) |
-| `anchors` | `{ type, data: [{ time, fret, width }] }` | Fret zoom anchors |
-| `chord_templates` | `{ type, data: [{ name, frets: [6] }] }` | Named chord shapes |
-| `lyrics` | `{ type, data: [{ w, t, d }], source }` | Syllables: `w`=word, `t`=time, `d`=duration. `-` joins to previous, `+` = line break. `source` is one of `"xml"`, `"whisperx"`, `"user"` — UI can use it to render an "auto-transcribed" badge for `whisperx`. Sloppaks always include `source` (legacy sloppaks without a `lyrics_source` manifest key default to `"xml"` at load time). Loose folders set it based on which extractor matched. Absent only when no lyrics fired the message at all |
-| `tone_changes` | `{ type: 'tone_changes', base, data: [{ time, name }] }` | Optional — tone change events relative to the arrangement base tone; only sent if tones were found |
-| `notes` | `{ type, data: [{ t, s, f, sus, ho, po, sl, bn, ... }] }` | Single notes |
-| `chords` | `{ type, data: [{ t, notes: [{ s, f, sus, ... }] }] }` | Chord events |
-| `phrases` | `{ type, data: [{ start_time, end_time, max_difficulty, levels: [{ difficulty, notes, chords, anchors, handshapes }] }], total }` | Optional — per-phrase difficulty ladder for master-difficulty slider (feedBack#48). Only sent when the source chart carries multi-level phrase data (phrase-aware sloppak). Sent in chunks (`data` is a batch, `total` is the full count across messages) to avoid multi-MB single frames. Absent for GP imports and legacy sloppak; consumers must treat missing message as "single fixed difficulty — slider disabled". |
-| `ready` | `{ type: 'ready' }` | All data sent — safe to finalize and start rendering |
-
-Message delivery is incremental. You may receive `loading` updates and `lyrics` before note/chord payloads; `tone_changes` comes after `lyrics` when present and may be omitted entirely. Do not finalize rendering until you receive `ready`.
-
-## Common Pitfalls
-
-1. **playSong wrapper race condition** — The wrapper chain runs outermost-first (last-loaded wrapper runs first). If an inner plugin (e.g. `3dhighway`) does `await import(CDN)`, it yields to the event loop. WebSocket messages (`song_info`, `ready`) can arrive before outer plugins set their callbacks. Use `getSongInfo()` as a fallback rather than relying solely on `_onReady`.
-
-2. **Plugin gitlinks** — Plugins are separate git repos cloned into `plugins/`. Switching branches on the main repo can delete or clobber these directories. Be careful with `git checkout` and `git clean`.
-
-3. **Highway flex layout** — `#highway` has `flex:1` in the player. Hiding it with `display:none` removes the flex child, causing `#player-controls` to float to the top. If you hide the highway, add `margin-top: auto` to the controls div to keep it at the bottom.
-
-4. **Multiple WebSocket connections** — The server supports many simultaneous WebSocket connections to the same song. Split screen panels, lyrics panes, and jumping tab panes each open their own. This is by design — don't try to multiplex.
-
-5. **Plugin load order** — Plugins load alphabetically by directory name. This determines the `playSong` wrapper chain order and which plugin's UI elements appear first. If your plugin depends on another's globals, check at runtime (`typeof window.X === 'function'`), not at load time.
+Everything you'd expect to find here - architecture, running the app, testing, conventions, plugin authoring, first-hour pitfalls - is imported above via `@AGENTS.md`. Updates go in `AGENTS.md`. This file only carries Claude-Code-specific automation references.

CONTRIBUTING.md

@@ -1,10 +1,10 @@
-# Contributing to FeedBack
+# Contributing to Slopsmith
 
 Thanks for wanting to contribute! This document covers the legal and workflow expectations for code, plugins, and documentation contributions.
 
 ## License
 
-FeedBack is licensed under [AGPL-3.0-only](LICENSE). Contributions you submit (PRs, patches, documentation, plugin entries in the curated list) are licensed inbound under the same terms — **inbound = outbound**. By opening a pull request, you agree that your contribution may be distributed under AGPL-3.0-only as part of FeedBack.
+Slopsmith is licensed under [AGPL-3.0-only](LICENSE). Contributions you submit (PRs, patches, documentation, plugin entries in the curated list) are licensed inbound under the same terms — **inbound = outbound**. By opening a pull request, you agree that your contribution may be distributed under AGPL-3.0-only as part of Slopsmith.
 
 ## Developer Certificate of Origin (DCO)
 
@@ -26,7 +26,7 @@ If you forget to sign off, amend the most recent commit with `git commit --amend
 
 ## Plugin licensing
 
-Plugins live in their own repositories and are loaded at runtime — see the [Plugin System section in CLAUDE.md](CLAUDE.md) for the technical contract, and [Plugin Best Practices](CLAUDE.md) for the conventions every plugin should follow (v2/v3 player chrome, the visualization contracts, and the **performance rules** — no per-frame DOM queries or broad `document.body` `MutationObserver`s — that keep the 60 fps highway smooth). Plugins are not subject to AGPL by being loaded into FeedBack (the loader runs them as separate Python modules / browser scripts), but for the **curated plugin list** to accept your plugin we ask that it be released under an AGPL-3.0-compatible license:
+Plugins live in their own repositories and are loaded at runtime — see [`docs/PLUGIN_AUTHORING.md`](docs/PLUGIN_AUTHORING.md) for the technical contract and [`schema/plugin.schema.json`](schema/plugin.schema.json) for the manifest schema. Plugins are not subject to AGPL by being loaded into Slopsmith (the loader runs them as separate Python modules / browser scripts), but for the **curated plugin list** to accept your plugin we ask that it be released under an AGPL-3.0-compatible license:
 
 - AGPL-3.0-only or AGPL-3.0-or-later
 - GPL-3.0-only or GPL-3.0-or-later
@@ -37,16 +37,16 @@ Plugins live in their own repositories and are loaded at runtime — see the [Pl
 - ISC
 - Unlicense / CC0-1.0 / 0BSD
 
-Plugins under GPL-2.0-only, LGPL-2.1-only, CDDL, EPL, or proprietary terms will not be added to the curated list. You're still free to publish and self-distribute them — FeedBack will load any plugin a user installs locally — but they won't be promoted from the main project.
+Plugins under GPL-2.0-only, LGPL-2.1-only, CDDL, EPL, or proprietary terms will not be added to the curated list. You're still free to publish and self-distribute them — Slopsmith will load any plugin a user installs locally — but they won't be promoted from the main project.
 
 ## Workflow
 
-Standard PR workflow described in [CLAUDE.md → Git Workflow](CLAUDE.md):
+Standard PR workflow described in [AGENTS.md → Git workflow](AGENTS.md#git-workflow):
 - Never push directly to `main`.
 - Create a feature branch on your fork.
-- Open a PR against `got-feedback/feedBack:main`.
+- Open a PR against `got-feedback/feedback:main`.
 - Keep commits scoped and well-described; short imperative subject + `Signed-off-by` trailer.
 
 ## Questions
 
-Open an issue or start a [Discussion](https://github.com/got-feedback/feedBack/discussions) if you're unsure whether a contribution fits — much better to ask early than to find out after the work is done.
+Open an issue or start a [Discussion](https://github.com/got-feedback/feedback/discussions) if you're unsure whether a contribution fits — much better to ask early than to find out after the work is done.

Dockerfile

@@ -47,11 +47,11 @@ RUN cmake -S /tmp/vgmstream -B /tmp/vgmstream/build \
 # and update FFMPEG_RELEASE + both SHA256 ARGs below.
 FROM alpine:3.20 AS ffmpeg-fetcher
 ARG TARGETARCH
-ARG FFMPEG_RELEASE=autobuild-2026-06-19-23-17
-ARG FFMPEG_BUILD_AMD64=ffmpeg-n7.1.4-145-g4cbf7a4b3d-linux64-gpl-7.1.tar.xz
-ARG FFMPEG_BUILD_ARM64=ffmpeg-n7.1.4-145-g4cbf7a4b3d-linuxarm64-gpl-7.1.tar.xz
-ARG FFMPEG_SHA256_AMD64=03c0431e0d1aa75cc343d83bda9d2d4cd8eaa37f35b7b93465e9ff6864f5d7f8
-ARG FFMPEG_SHA256_ARM64=74629b88342fd94eea12b7481c8b8560ca6d497744123c0a27b98f39d767fd93
+ARG FFMPEG_RELEASE=autobuild-2026-06-01-15-02
+ARG FFMPEG_BUILD_AMD64=ffmpeg-n7.1.4-7-gadcf20da26-linux64-gpl-7.1.tar.xz
+ARG FFMPEG_BUILD_ARM64=ffmpeg-n7.1.4-7-gadcf20da26-linuxarm64-gpl-7.1.tar.xz
+ARG FFMPEG_SHA256_AMD64=afde55344990650c117fbb7cb36b38d2ab6790b06beb06a9c43a9300c9ce277a
+ARG FFMPEG_SHA256_ARM64=03c8a7d9a7cf48d017a22a7c31acfdc8e76c5cb193923f883b0338c7baf0bd28
 RUN apk add --no-cache curl xz \
     && arch="${TARGETARCH:-$(apk --print-arch)}" \
     && case "$arch" in \
@@ -70,7 +70,7 @@ RUN apk add --no-cache curl xz \
 # ── Stage 1d: Build the Tailwind stylesheet over the FULL plugin set ──────
 # The committed static/tailwind.min.css is generated against only the in-tree
 # plugins. Rather than ship it as-is (leaving baked-in plugins' classes
-# unstyled now that the Play CDN's runtime JIT is gone — feedBack#411),
+# unstyled now that the Play CDN's runtime JIT is gone — slopsmith#411),
 # rebuild it here, after static/ + plugins/ are present, so the sheet covers
 # whatever plugins are baked into the image. Runs in a throwaway node stage so
 # this build-time toolchain never lands in the final image; the runtime node
@@ -94,9 +94,9 @@ FROM python:3.12-slim
 # Re-declare the ffmpeg ARGs so their values are available to LABEL below.
 # ARG values don't cross stage boundaries in multi-stage builds; defaults
 # must be repeated here to take effect when no --build-arg is supplied.
-ARG FFMPEG_RELEASE=autobuild-2026-06-19-23-17
-ARG FFMPEG_BUILD_AMD64=ffmpeg-n7.1.4-145-g4cbf7a4b3d-linux64-gpl-7.1.tar.xz
-ARG FFMPEG_BUILD_ARM64=ffmpeg-n7.1.4-145-g4cbf7a4b3d-linuxarm64-gpl-7.1.tar.xz
+ARG FFMPEG_RELEASE=autobuild-2026-06-01-15-02
+ARG FFMPEG_BUILD_AMD64=ffmpeg-n7.1.4-7-gadcf20da26-linux64-gpl-7.1.tar.xz
+ARG FFMPEG_BUILD_ARM64=ffmpeg-n7.1.4-7-gadcf20da26-linuxarm64-gpl-7.1.tar.xz
 
 # Apply latest security updates to base packages (clears glibc deb13u3 and
 # similar). Done first so any subsequent installs resolve against the
@@ -112,7 +112,7 @@ RUN apt-get update \
 # package drags in the full codec + TLS + graphics dependency tree
 # (mbedtls, gnutls28, mesa, x264, tiff, openjpeg2, libcaca, harfbuzz,
 # cairo, openldap, libcdio…), almost all of which has unfixed CVEs and
-# none of which FeedBack uses. We pull a static ffmpeg binary further
+# none of which Slopsmith uses. We pull a static ffmpeg binary further
 # down instead.
 #
 # vgmstream-cli is also built with -DUSE_FFMPEG=OFF (see stage 1b), so
@@ -142,7 +142,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
 
 # Node + the pinned Tailwind CLI for RUNTIME stylesheet regeneration. When a
-# plugin is installed into FEEDBACK_PLUGINS_DIR at runtime (or discovered
+# plugin is installed into SLOPSMITH_PLUGINS_DIR at runtime (or discovered
 # there on startup), the server rebuilds static/tailwind.min.css so the
 # plugin's classes are styled — the image-baked sheet only covered in-tree
 # plugins (see lib/tailwind_rebuild.py). tailwindcss is installed globally so
@@ -176,10 +176,10 @@ COPY --from=ffmpeg-fetcher /out/LICENSE.txt /usr/share/doc/ffmpeg/LICENSE.txt
 RUN chmod +x /usr/local/bin/ffmpeg /usr/local/bin/ffprobe
 # Record provenance so the exact BtbN source can be located for GPL compliance
 # or debugging. Inspect with: docker inspect <image> | grep -A5 ffmpeg
-LABEL org.feedBack.ffmpeg.release="${FFMPEG_RELEASE}" \
-      org.feedBack.ffmpeg.source.amd64="${FFMPEG_BUILD_AMD64}" \
-      org.feedBack.ffmpeg.source.arm64="${FFMPEG_BUILD_ARM64}" \
-      org.feedBack.ffmpeg.upstream="https://github.com/BtbN/FFmpeg-Builds"
+LABEL org.slopsmith.ffmpeg.release="${FFMPEG_RELEASE}" \
+      org.slopsmith.ffmpeg.source.amd64="${FFMPEG_BUILD_AMD64}" \
+      org.slopsmith.ffmpeg.source.arm64="${FFMPEG_BUILD_ARM64}" \
+      org.slopsmith.ffmpeg.upstream="https://github.com/BtbN/FFmpeg-Builds"
 
 # Native vgmstream-cli built against the image's own libraries
 COPY --from=vgmstream-builder /out/vgmstream-cli /usr/local/bin/vgmstream-cli

README.md

@@ -4,43 +4,50 @@
 
 | Plugin                                                                             | Description                                                                                                                                                                                                                      | Install                                                                 |
 |------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
-| [Create from Tab](https://github.com/got-feedback/feedBack-plugin-ug)             | Search Ultimate Guitar for GP tabs and convert to playable songs                                                                                                                                                                 | `git clone ...feedBack-plugin-ug.git ultimate_guitar`                  |
-| [Import Tab](https://github.com/got-feedback/feedBack-plugin-tabimport)           | Drag and drop Guitar Pro files to create songs                                                                                                                                                                                   | `git clone ...feedBack-plugin-tabimport.git tab_import`                |
-| [Practice Journal](https://github.com/got-feedback/feedBack-plugin-practice)      | Auto-track practice time, speed, loops. Dashboard with charts                                                                                                                                                                    | `git clone ...feedBack-plugin-practice.git practice_journal`           |
-| [Setlist Builder](https://github.com/got-feedback/feedBack-plugin-setlist)        | Create ordered playlists with sequential playback                                                                                                                                                                                | `git clone ...feedBack-plugin-setlist.git setlist`                     |
-| [Metronome](https://github.com/got-feedback/feedBack-plugin-metronome)            | Audible click and visual beat flash synced to song tempo                                                                                                                                                                         | `git clone ...feedBack-plugin-metronome.git metronome`                 |
-| [Tone Player](https://github.com/got-feedback/feedBack-plugin-tones)              | View amp/pedal/cab signal chains with gear artwork                                                                                                                                                                               | `git clone ...feedBack-plugin-tones.git tones`                         |
-| [Fretboard View](https://github.com/got-feedback/feedBack-plugin-fretboard)       | Live fretboard overlay showing active notes in real-time                                                                                                                                                                         | `git clone ...feedBack-plugin-fretboard.git fretboard`                 |
-| [Tab View](https://github.com/got-feedback/feedBack-plugin-tabview)               | Scrolling guitar tablature notation via alphaTab                                                                                                                                                                                 | `git clone ...feedBack-plugin-tabview.git tab_view`                    |
-| [MIDI Amp Control](https://github.com/got-feedback/feedBack-plugin-midi)          | Auto-switch amp/modeler presets via MIDI on tone changes                                                                                                                                                                         | `git clone ...feedBack-plugin-midi.git midi_amp`                       |
-| [Section Map](https://github.com/got-feedback/feedBack-plugin-sectionmap)         | Color-coded song structure minimap with clickable navigation                                                                                                                                                                     | `git clone ...feedBack-plugin-sectionmap.git section_map`              |
-| [Arrangement Editor](https://github.com/got-feedback/feedBack-plugin-editor)      | DAW-like visual editor for creating and editing song note charts                                                                                                                                                                 | `git clone ...feedBack-plugin-editor.git editor`                       |
+| [Create from Tab](https://github.com/got-feedback/feedback-plugin-ug)             | Search Ultimate Guitar for GP tabs and convert to playable songs                                                                                                                                                                 | `git clone ...slopsmith-plugin-ug.git ultimate_guitar`                  |
+| [Import Tab](https://github.com/got-feedback/feedback-plugin-tabimport)           | Drag and drop Guitar Pro files to create songs                                                                                                                                                                                   | `git clone ...slopsmith-plugin-tabimport.git tab_import`                |
+| [Practice Journal](https://github.com/got-feedback/feedback-plugin-practice)      | Auto-track practice time, speed, loops. Dashboard with charts                                                                                                                                                                    | `git clone ...slopsmith-plugin-practice.git practice_journal`           |
+| [Setlist Builder](https://github.com/got-feedback/feedback-plugin-setlist)        | Create ordered playlists with sequential playback                                                                                                                                                                                | `git clone ...slopsmith-plugin-setlist.git setlist`                     |
+| [Metronome](https://github.com/got-feedback/feedback-plugin-metronome)            | Audible click and visual beat flash synced to song tempo                                                                                                                                                                         | `git clone ...slopsmith-plugin-metronome.git metronome`                 |
+| [Tone Player](https://github.com/got-feedback/feedback-plugin-tones)              | View amp/pedal/cab signal chains with gear artwork                                                                                                                                                                               | `git clone ...slopsmith-plugin-tones.git tones`                         |
+| [Fretboard View](https://github.com/got-feedback/feedback-plugin-fretboard)       | Live fretboard overlay showing active notes in real-time                                                                                                                                                                         | `git clone ...slopsmith-plugin-fretboard.git fretboard`                 |
+| [Tab View](https://github.com/got-feedback/feedback-plugin-tabview)               | Scrolling guitar tablature notation via alphaTab                                                                                                                                                                                 | `git clone ...slopsmith-plugin-tabview.git tab_view`                    |
+| [MIDI Amp Control](https://github.com/got-feedback/feedback-plugin-midi)          | Auto-switch amp/modeler presets via MIDI on tone changes                                                                                                                                                                         | `git clone ...slopsmith-plugin-midi.git midi_amp`                       |
+| [Section Map](https://github.com/got-feedback/feedback-plugin-sectionmap)         | Color-coded song structure minimap with clickable navigation                                                                                                                                                                     | `git clone ...slopsmith-plugin-sectionmap.git section_map`              |
+| [Arrangement Editor](https://github.com/got-feedback/feedback-plugin-editor)      | DAW-like visual editor for creating and editing song note charts                                                                                                                                                                 | `git clone ...slopsmith-plugin-editor.git editor`                       |
 | [MIDI Capo](https://github.com/masc0t/slopsmith-plugin-midi-capo)                  | MIDI capo control for real-time transposition                                                                                                                                                                                    | `git clone ...slopsmith-plugin-midi-capo.git midi_capo`                 |
-| [Note Detection](https://github.com/got-feedback/feedBack-plugin-notedetect)      | Real-time pitch detection and scoring against highway notes                                                                                                                                                                      | `git clone ...feedBack-plugin-notedetect.git note_detect`              |
+| [Note Detection](https://github.com/got-feedback/feedback-plugin-notedetect)      | Real-time pitch detection and scoring against highway notes                                                                                                                                                                      | `git clone ...slopsmith-plugin-notedetect.git note_detect`              |
 | [Find More](https://github.com/masc0t/slopsmith-plugin-find-more)                  | Search for more songs by the same artist                                                                                                                                                                                         | `git clone ...slopsmith-plugin-find-more.git find_more`                 |
-| [Piano Highway](https://github.com/got-feedback/feedBack-plugin-piano)            | Scrolling piano/keyboard view for Keys arrangements with MIDI input                                                                                                                                                              | `git clone ...feedBack-plugin-piano.git piano`                         |
-| [Studio](https://github.com/got-feedback/feedBack-plugin-studio)                  | Collaborative band recording and multi-track mixing                                                                                                                                                                              | `git clone ...feedBack-plugin-studio.git studio`                       |
-| [Drum Highway](https://github.com/got-feedback/feedBack-plugin-drums)             | Lane-based drum highway with MIDI drum pad input and built-in sounds                                                                                                                                                             | `git clone ...feedBack-plugin-drums.git drums`                         |
+| [Piano Highway](https://github.com/got-feedback/feedback-plugin-piano)            | Scrolling piano/keyboard view for Keys arrangements with MIDI input                                                                                                                                                              | `git clone ...slopsmith-plugin-piano.git piano`                         |
+| [Studio](https://github.com/got-feedback/feedback-plugin-studio)                  | Collaborative band recording and multi-track mixing                                                                                                                                                                              | `git clone ...slopsmith-plugin-studio.git studio`                       |
+| [Drum Highway](https://github.com/got-feedback/feedback-plugin-drums)             | Lane-based drum highway with MIDI drum pad input and built-in sounds                                                                                                                                                             | `git clone ...slopsmith-plugin-drums.git drums`                         |
+| [Split Screen](https://github.com/topkoa/slopsmith-plugin-splitscreen)             | 2-4 highway panels side-by-side for multi-arrangement practice                                                                                                                                                                   | `git clone ...slopsmith-plugin-splitscreen.git splitscreen`             |
+| [Stems Mixer](https://github.com/topkoa/slopsmith-plugin-stems)                    | Per-stem mute/volume controls for .sloppak songs                                                                                                                                                                                 | `git clone ...slopsmith-plugin-stems.git stems`                         |
 | [Invert Highway](https://github.com/masc0t/slopsmith-plugin-invert-highway)        | Flip the highway note direction                                                                                                                                                                                                  | `git clone ...slopsmith-plugin-invert-highway.git invert_highway`       |
 | [Jumping Tab](https://github.com/renanboni/slopsmith-plugin-jumpingtab)            | Yousician-style 2D horizontal tab with trajectory arcs and hopping ball                                                                                                                                                          | `git clone ...slopsmith-plugin-jumpingtab.git jumpingtab`               |
-| [Step Mode](https://github.com/got-feedback/feedBack-plugin-stepmode)             | Step-by-step practice mode — highway freezes at each note until played (via Note Detection) or Space                                                                                                                             | `git clone ...feedBack-plugin-stepmode.git step_mode`                  |
-| [Lyrics Sync](https://github.com/got-feedback/feedBack-plugin-lyrics-sync)        | Generate synced LRC lyrics from text + vocals stem via Whisper alignment                                                                                                                                                         | `git clone ...feedBack-plugin-lyrics-sync.git lyrics_sync`             |
-| [Lyrics Karaoke](https://github.com/got-feedback/feedBack-plugin-lyrics-karaoke)  | Per-syllable karaoke pitch ribbon for sloppak songs (Whisper alignment + librosa pYIN)                                                                                                                                           | `git clone ...feedBack-plugin-lyrics-karaoke.git lyrics_karaoke`       |
-| [NAM Tone Engine](https://github.com/got-feedback/feedBack-plugin-nam-tone)       | In-browser amp modeling with NAM WASM, cabinet IRs, tone auto-switching                                                                                                                                                          | `git clone ...feedBack-plugin-nam-tone.git nam_tone`                   |
-| [Guitar Theory Lab](https://github.com/topkoa/slopsmith-plugin-guitar-theory)      | Explore scales, chords, intervals, tunings, and voicings on a fully interactive fretboard                                                                                                                                        | `git clone ...slopsmith-plugin-guitar-theory.git guitar-theory-lab`          |
+| [Step Mode](https://github.com/got-feedback/feedback-plugin-stepmode)             | Step-by-step practice mode — highway freezes at each note until played (via Note Detection) or Space                                                                                                                             | `git clone ...slopsmith-plugin-stepmode.git step_mode`                  |
+| [Lyrics Sync](https://github.com/got-feedback/feedback-plugin-lyrics-sync)        | Generate synced LRC lyrics from text + vocals stem via Whisper alignment                                                                                                                                                         | `git clone ...slopsmith-plugin-lyrics-sync.git lyrics_sync`             |
+| [Lyrics Karaoke](https://github.com/got-feedback/feedback-plugin-lyrics-karaoke)  | Per-syllable karaoke pitch ribbon for sloppak songs (Whisper alignment + librosa pYIN)                                                                                                                                           | `git clone ...slopsmith-plugin-lyrics-karaoke.git lyrics_karaoke`       |
+| [NAM Tone Engine](https://github.com/got-feedback/feedback-plugin-nam-tone)       | In-browser amp modeling with NAM WASM, cabinet IRs, tone auto-switching                                                                                                                                                          | `git clone ...slopsmith-plugin-nam-tone.git nam_tone`                   |
+| [Guitar Theory Lab](https://github.com/topkoa/slopsmith-plugin-guitar-theory)      | Explore scales, chords, intervals, tunings, and voicings on a fully interactive fretboard                                                                                                                                        | `git clone ...slopsmith-plugin-nam-tone.git guitar-theory-lab`          |
 | [Themes](https://github.com/masc0t/slopsmith-plugin-themes)                        | Offers several basic recolorings of the interface                                                                                                                                                                                | `git clone ...slopsmith-plugin-themes.git themes`                       |
-| [Update Manager](https://github.com/masc0t/slopsmith-update-manager)               | Installs, updates, and uninstalls other plugins and the feedBack core itself                                                                                                                                                    | `git clone ...slopsmith-update-manager.git update_manager`              |
+| [Update Manager](https://github.com/masc0t/slopsmith-update-manager)               | Installs, updates, and uninstalls other plugins and the slopsmith core itself                                                                                                                                                    | `git clone ...slopsmith-update-manager.git update_manager`              |
+| [Tuner](https://github.com/OmikronApex/slopsmith-plugin-tuner)                     | Floating tuner with customizable tunings                                                                                                                                                                                         | `git clone ...slopsmith-plugin-tuner.git tuner`                         |
 | [Simplify Chords](https://github.com/bkranendonk/slopsmith-plugin-simplify-chords) | Changes complex chords on the note highway to simpler ones. Inspired by Ultimate Guitar's Simplify button.                                                                                                                       | `git clone ...slopsmith-plugin-simplify-chords.git simplify-chords`     |
 | [Key Bindings](https://github.com/jackipicco/slopsmith-plugin-key-bindings)        | Highway key bindings for keyboard and TV remote                                                                                                                                                                                  | `git clone ...slopsmith-plugin-key-bindings.git key_bindings`           |
-| [Virtuoso](https://github.com/got-feedback/feedBack-plugin-virtuoso)               | Practice studio for guitar & bass — scale, technique, and rhythm drills, timed workouts, and jam backing that teach skills you take off the screen.                                                                              | `git clone ...feedBack-plugin-virtuoso.git virtuoso`                    |
+| [Folder Organizer](https://github.com/Elit3d/slopsmith-plugin-folder-organizer)    | Organize your sloppak DLC songs into a folder tree view, grouped by subfolder name                                                                                                                                               | `git clone ...slopsmith-plugin-folder-organizer.git folder-organizer`   |
+| [SlopScale](https://github.com/ChrisBeWithYou/slopsmith-plugin-slopscale)          | Scale, arpeggio, and sweep-arpeggio practice routines with 3D highway, 2D highway, and tab renderers. Pathway selector, CAGED shape-run arpeggios, and generated audio backing.                                                  | `git clone ...slopsmith-plugin-slopscale.git slopscale`                 |
+| [NAM Rig Builder](https://github.com/Jafz2001/slopsmith-plugin-nam-rig-builder)    | Map tones to chained NAM neural-amp rigs (tone3000 captures + IRs) — full pedal→amp→cab playback, per-stage bypass, and a gear catalog                                                                                           | `git clone ...slopsmith-plugin-nam-rig-builder.git nam_rig_builder`     |
 | [Audio Preview](https://github.com/saleemk/slopsmith-plugin-audio-preview)         | Quick audio previews from library cards with configurable start time, volume, and duration                                                                                                                                       | `git clone ...slopsmith-plugin-audio-preview.git audio_preview`         |
 | [Song Mastery](https://github.com/jamesgaiser/slopsmith-plugin-song-mastery)       | Auto-adjusts difficulty based on your rolling note accuracy and saves the slider position per song                                                                                                                               | `git clone ...slopsmith-plugin-song-mastery.git song_mastery`           |
+| [Song Preview](https://github.com/DeathlySin/slopsmith-plugin-song-preview)        | Quickly hear previews of songs in your library with a clean visual indicator of what's playing. Supports .sloppak and loose folders song formats, with the visual indicator matching up to whatever theme you are using!         | `git clone ...slopsmith-plugin-song-preview.git song_preview`           |
 | [Mobile Note Highway](https://github.com/saleemk/slopsmith-plugin-mobile-note-highway) | Touch-optimized player with collapsible controls, highway gestures, and device-adaptive layouts for phones and tablets | `git clone ...slopsmith-plugin-mobile-note-highway.git mobile_note_highway` |
+| [Shuffle](https://github.com/Erikcb91/Slopsmith-Shuffle-Mode) | Random playback from your library — artist & tuning filters, auto-advance with countdown popup, note_detect compatible | `git clone https://github.com/Erikcb91/Slopsmith-Shuffle-Mode.git shuffle` |
 
 Install any plugin by cloning it into your `plugins/` directory and restarting:
 
 ```bash
 cd plugins
-git clone https://github.com/got-feedback/feedBack-plugin-ug.git ultimate_guitar
+git clone https://github.com/got-feedback/feedback-plugin-ug.git ultimate_guitar
 docker compose restart
 ```

SUPPORTERS.md

@@ -1,8 +1,8 @@
 # Supporters
 
-FeedBack's development is supported by these generous people. Thank you. ❤️
+Slopsmith's development is supported by these generous people. Thank you. ❤️
 
-Want to be listed here? See [Support FeedBack](README.md#support-feedBack).
+Want to be listed here? See [Support Slopsmith](README.md#support-slopsmith).
 
 ## Patrons
 

VERSION

@@ -1 +1 @@
-0.3.0
+0.2.9

build-proxmox-ct.sh

@@ -9,8 +9,8 @@
 #   sudo bash build-proxmox-ct.sh [TARGETARCH] [OUTPUT_NAME]
 #
 # Examples:
-#   sudo bash build-proxmox-ct.sh amd64 feedBack-ct
-#   sudo bash build-proxmox-ct.sh arm64 feedBack-ct
+#   sudo bash build-proxmox-ct.sh amd64 slopsmith-ct
+#   sudo bash build-proxmox-ct.sh arm64 slopsmith-ct
 #
 # The resulting container ships empty; mount or copy your .sloppak /
 # loose-folder library into /dlc inside the CT after import.
@@ -26,13 +26,13 @@
 #   sudo apt install debootstrap systemd-container tar zstd curl unzip git
 #
 # On Proxmox, after transfer:
-#   pct restore <VMID> feedBack-ct.tar.zst --storage local-lvm --rootfs 8 --unprivileged 1
+#   pct restore <VMID> slopsmith-ct.tar.zst --storage local-lvm --rootfs 8 --unprivileged 1
 # =============================================================================
 
 set -euo pipefail
 
 TARGETARCH="${1:-amd64}"
-OUTPUT_NAME="${2:-feedBack-ct}"
+OUTPUT_NAME="${2:-slopsmith-ct}"
 
 # OUTPUT_NAME is a positional arg that flows into BUILD_BASE (interpolated into
 # `mkdir -p` / `rm -rf` paths) and into the final tarball name. Reject anything
@@ -104,7 +104,7 @@ VENV_DIR="/opt/app-venv"
 PIP_VERSION="26.1.1"
 DLC_DIR="/dlc"
 CONFIG_DIR="/config"
-SVC_USER="feedBack"
+SVC_USER="slopsmith"
 
 # Coloured logging
 info() { echo -e "\033[1;34m[INFO]\033[0m  $*"; }
@@ -420,7 +420,7 @@ ok "Build dependencies removed."
 # =============================================================================
 # 5d. Tailwind CLI for runtime stylesheet regeneration
 # =============================================================================
-# When a plugin is installed into FEEDBACK_PLUGINS_DIR at runtime (or
+# When a plugin is installed into SLOPSMITH_PLUGINS_DIR at runtime (or
 # discovered there on startup), the server rebuilds static/tailwind.min.css
 # so the plugin's classes are styled — the image-baked sheet only covers
 # in-tree plugins (see lib/tailwind_rebuild.py). tailwindcss is installed
@@ -523,11 +523,11 @@ info "Creating service user '${SVC_USER}' …"
 r "useradd --system --home-dir ${APP_DIR} --shell /usr/sbin/nologin ${SVC_USER}"
 ok "User '${SVC_USER}' created."
 
-info "Installing feedBack-server.service …"
+info "Installing slopsmith-server.service …"
 mkdir -p "${ROOTFS}/etc/systemd/system"
-cat > "${ROOTFS}/etc/systemd/system/feedBack-server.service" <<EOF
+cat > "${ROOTFS}/etc/systemd/system/slopsmith-server.service" <<EOF
 [Unit]
-Description=FeedBack uvicorn server
+Description=Slopsmith uvicorn server
 After=network.target
 
 [Service]
@@ -547,8 +547,8 @@ EOF
 
 # Enable by symlinking (avoids running systemctl inside nspawn)
 mkdir -p "${ROOTFS}/etc/systemd/system/multi-user.target.wants"
-ln -sf /etc/systemd/system/feedBack-server.service \
-       "${ROOTFS}/etc/systemd/system/multi-user.target.wants/feedBack-server.service"
+ln -sf /etc/systemd/system/slopsmith-server.service \
+       "${ROOTFS}/etc/systemd/system/multi-user.target.wants/slopsmith-server.service"
 ok "Service enabled."
 
 # =============================================================================
@@ -662,6 +662,6 @@ cat <<DONE
         --start 1
 
   Then check the server:
-    pct exec 200 -- systemctl status feedBack-server
+    pct exec 200 -- systemctl status slopsmith-server
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 DONE

docker-compose.nas.yml

@@ -7,17 +7,17 @@ services:
       - "8000:8000"
     volumes:
       # Song library folder on NAS
-      - /volume1/music/feedBack:/dlc
+      - /volume1/music/slopsmith:/dlc
       # Persistent config, cache, favorites, loops, practice data
-      - feedBack-config:/config
+      - slopsmith-config:/config
     environment:
       - DLC_DIR=/dlc
       - CONFIG_DIR=/config
       # Logging (optional)
       # - LOG_LEVEL=INFO        # DEBUG | INFO | WARNING | ERROR  (default: INFO)
       # - LOG_FORMAT=json       # json | text  (default: text)
-      # - LOG_FILE=/config/feedBack.log  # also write to a persistent file
+      # - LOG_FILE=/config/slopsmith.log  # also write to a persistent file
     restart: unless-stopped
 
 volumes:
-  feedBack-config:
+  slopsmith-config:

docker-compose.yml

@@ -7,7 +7,7 @@ services:
       # Mount your song library folder (adjust path for your system)
       - ${LIBRARY_PATH:-./library}:/dlc
       # Persistent config and cache
-      - feedBack-config:/config
+      - slopsmith-config:/config
       # Mount source for live reload during development
       - ./static:/app/static
       - ./server.py:/app/server.py
@@ -28,10 +28,10 @@ services:
       # Logging (optional)
       # - LOG_LEVEL=DEBUG       # DEBUG | INFO | WARNING | ERROR  (default: INFO)
       # - LOG_FORMAT=json       # json | text  (default: text — coloured console)
-      # - LOG_FILE=/config/feedBack.log  # also write to a persistent file
+      # - LOG_FILE=/config/slopsmith.log  # also write to a persistent file
     dns:
       - 8.8.8.8
       - 1.1.1.1
 
 volumes:
-  feedBack-config:
+  slopsmith-config:

docs/NOTE_FAILURE_PLAN.md

@@ -9,10 +9,10 @@ Depends on: `docs/NOTE_FAILURE_SPEC.md` (read that first)
 **Goal:** Working note detection plugin streaming detected notes via WebSocket.
 
 This phase was previously tracked in a separate NOTE_DETECTION_PLUGIN_PLAN
-document (in the `feedBack-plugin-notedetect` repository). The relevant scope
+document (in the `slopsmith-plugin-notedetect` repository). The relevant scope
 is summarized here to avoid relying on an internal git-only reference:
 
-- [ ] Plugin skeleton: `feedBack-plugin-notedetect/` with plugin.json, routes.py, screen.js
+- [ ] Plugin skeleton: `slopsmith-plugin-notedetect/` with plugin.json, routes.py, screen.js
 - [ ] Port TonalRecall YIN detection (aubio + sounddevice) to routes.py
 - [ ] WebSocket at `/api/plugins/note_detect/stream` streaming `{ note, freq, confidence, time }`
 - [ ] Device selection UI in screen.html
@@ -138,7 +138,7 @@ shows the correct diagnostic labels.
   ```
   Displayed for 1.5s, then fades.
 - [ ] Track `bestIteration` across all iterations for "Best" display
-- [ ] Emit `loop:complete` event via `window.feedBack.emit()` so other plugins
+- [ ] Emit `loop:complete` event via `window.slopsmith.emit()` so other plugins
       (practice journal) can record the data
 - [ ] Reset loop history when loop boundaries change or loop is cleared
 

docs/NOTE_FAILURE_SPEC.md

@@ -13,7 +13,7 @@ late, wrong pitch, or not played at all.
 
 ## Prerequisites
 
-This feature depends on the **note detection plugin** (`feedBack-plugin-notedetect`),
+This feature depends on the **note detection plugin** (`slopsmith-plugin-notedetect`),
 which provides real-time pitch detection via server-side aubio/YIN over WebSocket.
 The detection plugin streams `DetectedNote` events; this spec describes the
 **matching, judgment, and rendering** layer that consumes those events.
@@ -55,10 +55,10 @@ Guitar → USB Adapter → sounddevice (server)
    Wire format: `{ note: "A2", freq: 110.0, confidence: 0.92, time: 1.234 }`
 
    > **Plugin naming note:** The detection plugin's repository is named
-   > `feedBack-plugin-notedetect`, but the plugin registers with the id
+   > `slopsmith-plugin-notedetect`, but the plugin registers with the id
    > `note_detect` (snake_case). Its HTTP/WebSocket routes therefore appear
-   > under `/api/plugins/note_detect/…`. There is no `window.feedBackPlugin_*`
-   > global pattern in FeedBack — to check whether the detection plugin is
+   > under `/api/plugins/note_detect/…`. There is no `window.slopsmithPlugin_*`
+   > global pattern in Slopsmith — to check whether the detection plugin is
    > available at runtime, attempt a fetch to `/api/plugins/note_detect/status`
    > (or similar) or consult the `/api/plugins` list. Use the repo name only
    > in documentation links.
@@ -335,7 +335,7 @@ The tracker must handle A-B looping:
 | `loopA`, `loopB`             | Current A-B loop boundaries              |
 | `audio.currentTime`          | Actual audio playback position           |
 
-### New Events Emitted (via `window.feedBack.emit`)
+### New Events Emitted (via `window.slopsmith.emit`)
 
 | Event                        | Payload                                  |
 |------------------------------|------------------------------------------|
@@ -373,7 +373,7 @@ There are three distinct threshold tiers — keep them conceptually separate:
 | `hitGlowDuration`      | 0.5     | Green glow fade time (sec)                                     |
 
 Persist these settings in plugin-local storage (e.g. `localStorage` prefixed
-with the plugin id). Do **not** assume they can be saved through FeedBack's
+with the plugin id). Do **not** assume they can be saved through Slopsmith's
 `/api/settings` endpoint under a `notedetect_feedback` key — the current server
 only persists a fixed set of known settings keys. If backend support for a
 dedicated persisted key is added later, this plugin may migrate to `/api/settings`.

docs/PLUGIN_AUTHORING.md

@@ -0,0 +1,61 @@
+# Plugin Authoring Guide
+
+Slopsmith's plugin system is the primary extension point. Each plugin lives in `plugins/<name>/` with a `plugin.json` manifest that declares the capability domains, UI contributions, settings metadata, diagnostics, and runtime files the plugin participates in.
+
+This guide is the entry point. Each topic below has a dedicated doc — read what's relevant to what you're building.
+
+## Quickstart
+
+```text
+plugins/my_plugin/
+├── plugin.json          Manifest (required) — see docs/plugin-manifest.md
+├── screen.html          Optional — UI declared through `ui` contributions
+├── screen.js            Optional — hydrates declared frontend capabilities
+├── routes.py            Optional — backend provider/requester implementation
+├── settings.html        Optional — settings UI declared through `ui.settings`
+└── requirements.txt     Optional — pip deps auto-installed on load
+```
+
+Start every plugin by describing its Slopsmith-facing behavior in the manifest with `standards: ["capability-pipelines.v1"]`, native `capabilities`, and redaction-safe `ui` metadata. A plugin with no app-facing behavior beyond metadata can still be this small:
+
+```json
+{
+  "id": "my_plugin",
+  "name": "My Plugin",
+  "version": "0.1.0"
+}
+```
+
+Capability declarations are the source of truth for diagnostics, the Capability Inspector, and plugin tooling. Treat missing capability metadata as an intentional exception for metadata-only or transitional plugin manifests.
+
+## Topics
+
+| Topic | Doc | When to read |
+|---|---|---|
+| **Manifest reference** | [plugin-manifest.md](plugin-manifest.md) | Field-by-field reference for `plugin.json`. Read first. |
+| **Capability declarations** | [plugin-manifest.md#capabilities](plugin-manifest.md#capabilities) | Declaring provider/requester/observer intent with `capability-pipelines.v1`. |
+| **Capability domains** | [capability-domains.md](capability-domains.md) | Active domains, planned domains, and promotion rules. |
+| **Capability recipes** | [capability-recipes.md](capability-recipes.md) | Copyable manifest patterns for provider/requester/observer plugins. |
+| **Visualization contracts** | [plugin-visualization-contracts.md](plugin-visualization-contracts.md) | Building a highway renderer (setRenderer), an overlay layer, or a note-state provider. |
+| **Plugin styles** | [plugin-styles.md](plugin-styles.md) | Shipping a plugin-owned prebuilt stylesheet via `styles: "assets/plugin.css"`. |
+| **Backend logging** | [plugin-logging.md](plugin-logging.md) | Plugin has a `routes.py`. Use `context["log"]`, never `print()`. |
+| **Diagnostics contribution** | [plugin-diagnostics.md](plugin-diagnostics.md) | Adding plugin state to the Export Diagnostics bundle. |
+| **Sibling Python imports** | [plugin-sibling-imports.md](plugin-sibling-imports.md) | Multi-file backend plugins. Use `context["load_sibling"]`. |
+| **WebSocket protocol** | [websocket-protocol.md](websocket-protocol.md) | Plugins that read the highway stream directly. |
+| **Testing plugins** | [testing-plugins.md](testing-plugins.md) | Conftest fixtures and Playwright patterns for plugin tests. |
+| **Diagnostics bundle spec** | [diagnostics-bundle-spec.md](diagnostics-bundle-spec.md) | Existing in-depth spec — what's inside a diagnostics export. |
+| **Sloppak format spec** | [sloppak-spec.md](sloppak-spec.md) | Existing in-depth spec — for plugins that read/write sloppaks. |
+
+## General guidelines
+
+- Wrap your plugin code in an IIFE: `(function () { 'use strict'; ... })();`
+- Declare `standards: ["capability-pipelines.v1"]` and native `capabilities` for the plugin's Slopsmith-facing behavior.
+- Use `ui` / `ui_contributions` for plugin-owned UI surfaces so the host can attribute them in diagnostics and support bundles.
+- Use `localStorage` for user-facing settings, prefixed with your plugin id.
+- Prefer native capability commands, events, and provider registration over private globals. If a domain you need is not active yet, document the gap in the PR instead of baking in a new private integration.
+
+## Licensing for curated plugins
+
+Plugins submitted for inclusion in Slopsmith must use AGPL-3.0-only. See [CONTRIBUTING.md](../CONTRIBUTING.md) for the full policy. The `plugin.json` schema enforces this via the `license` field enum — see [plugin-manifest.md](plugin-manifest.md).
+
+Add an `SPDX-License-Identifier: AGPL-3.0-only` comment to plugin source files (`screen.js`, `routes.py`, helper modules, and similar authored code) so the manifest license and source-file metadata stay aligned.

docs/benchmarks/note_detect_bass_v1/BENCHMARK.md

@@ -1,4 +1,4 @@
-# FeedBack Note Detect Bass Benchmark — v1
+# Slopsmith Note Detect Bass Benchmark — v1
 
 A bass-focused companion to the guitar benchmarks
 (note_detect_v1 + note_detect_v2). Tests `note_detect` against bass-

docs/benchmarks/note_detect_bass_v1/build_benchmark.py

@@ -20,11 +20,11 @@ the guitar one:
   than guitar E2 at ~82 Hz. The benchmark should exercise that
   regime explicitly so we can spot regressions there.
 
-How to run inside the feedBack container:
+How to run inside the slopsmith container:
 
     docker cp docs/benchmarks/note_detect_bass_v1/build_benchmark.py \\
-              feedBack-web-1:/tmp/build_benchmark_bass.py
-    docker exec feedBack-web-1 python /tmp/build_benchmark_bass.py \\
+              slopsmith-web-1:/tmp/build_benchmark_bass.py
+    docker exec slopsmith-web-1 python /tmp/build_benchmark_bass.py \\
               /app/static/sloppak_cache/note_detect_benchmark_bass_v1.sloppak
 
 After regenerating, copy the zip output to the tracked path with the
@@ -351,7 +351,7 @@ def build(out_dir: Path):
 
     arrangement = {
         'name': 'Bass',
-        # Pad to 6 slots even on bass — feedBack's `tuning_name()` only
+        # Pad to 6 slots even on bass — slopsmith's `tuning_name()` only
         # recognises named tunings (E Standard, Drop D, etc.) on 6-element
         # arrays, so a 4-element array shows up in the library card as the
         # raw numeric form ("0 0 0 0") instead of "E Standard". The
@@ -371,7 +371,7 @@ def build(out_dir: Path):
 
     manifest = {
         'title': 'Note Detect Bass Benchmark v1',
-        'artist': 'FeedBack',
+        'artist': 'Slopsmith',
         'album': 'Note Detection Benchmark',
         'year': 2026,
         'duration': round(end_t, 3),
@@ -389,7 +389,7 @@ def build(out_dir: Path):
             {'id': 'full', 'file': 'stems/full.ogg', 'default': True},
         ],
         'benchmark': {
-            'id': 'feedBack-note-detect-benchmark-bass',
+            'id': 'slopsmith-note-detect-benchmark-bass',
             'version': 1,
         },
     }
@@ -461,7 +461,7 @@ def _build_zip(src_dir: Path):
 
 
 def _benchmark_readme(duration_s):
-    return f"""# FeedBack Note Detect Bass Benchmark — v1
+    return f"""# Slopsmith Note Detect Bass Benchmark — v1
 
 A bass-focused companion to the guitar benchmarks
 (note_detect_v1 + note_detect_v2). Tests `note_detect` against bass-

docs/benchmarks/note_detect_v1/BENCHMARK.md

@@ -1,6 +1,6 @@
-# FeedBack Note Detect Benchmark — v1
+# Slopsmith Note Detect Benchmark — v1
 
-A short test piece for tuning FeedBack's `note_detect` plugin. Eight
+A short test piece for tuning Slopsmith's `note_detect` plugin. Eight
 exercises, each isolating a specific detection failure mode. Run with
 **Detect** enabled, play through, then export the diagnostic JSON
 (Settings → Plugins → Note Detection → Download Diagnostic JSON, or
@@ -43,4 +43,4 @@ Share the JSON (schema `note_detect.diagnostic.v1`). It includes:
 ## Source
 
 Built by `docs/benchmarks/note_detect_v1/build_benchmark.py` in the
-feedBack repo. Tweak the exercise list there and regenerate.
+slopsmith repo. Tweak the exercise list there and regenerate.

docs/benchmarks/note_detect_v1/build_benchmark.py

@@ -5,12 +5,12 @@ short exercises designed to isolate specific failure modes (open-string
 mono, fretted positions, octaves, sustained held notes, hammer-on /
 pull-off, sparse power chords, dense open chords, bends).
 
-How to run inside the feedBack container (recommended — has ffmpeg +
+How to run inside the slopsmith container (recommended — has ffmpeg +
 pyyaml already):
 
     docker cp docs/benchmarks/note_detect_v1/build_benchmark.py \
-              feedBack-web-1:/tmp/build_benchmark.py
-    docker exec feedBack-web-1 python /tmp/build_benchmark.py \
+              slopsmith-web-1:/tmp/build_benchmark.py
+    docker exec slopsmith-web-1 python /tmp/build_benchmark.py \
               /app/static/sloppak_cache/note_detect_benchmark_v1.sloppak
 
 The output sloppak lands under `static/sloppak_cache/` on the host
@@ -26,7 +26,7 @@ import sys
 import wave
 from pathlib import Path
 
-import yaml  # bundled with the feedBack image
+import yaml  # bundled with the slopsmith image
 
 # ── Benchmark parameters ────────────────────────────────────────────────
 BPM = 90.0
@@ -411,7 +411,7 @@ def build(out_dir: Path):
 
     manifest = {
         'title': 'Note Detect Benchmark v1',
-        'artist': 'FeedBack',
+        'artist': 'Slopsmith',
         'album': 'Note Detection Benchmark',
         'year': 2026,
         'duration': round(end_t, 3),
@@ -430,7 +430,7 @@ def build(out_dir: Path):
         # Non-standard key — picked up by future tooling that wants to
         # detect "this is the benchmark, schema v1". The loader ignores it.
         'benchmark': {
-            'id': 'feedBack-note-detect-benchmark',
+            'id': 'slopsmith-note-detect-benchmark',
             'version': 1,
         },
     }
@@ -545,9 +545,9 @@ def _build_zip(src_dir: Path):
 
 
 def _benchmark_readme(duration_s):
-    return f"""# FeedBack Note Detect Benchmark — v1
+    return f"""# Slopsmith Note Detect Benchmark — v1
 
-A short test piece for tuning FeedBack's `note_detect` plugin. Eight
+A short test piece for tuning Slopsmith's `note_detect` plugin. Eight
 exercises, each isolating a specific detection failure mode. Run with
 **Detect** enabled, play through, then export the diagnostic JSON
 (Settings → Plugins → Note Detection → Download Diagnostic JSON, or
@@ -590,7 +590,7 @@ Share the JSON (schema `note_detect.diagnostic.v1`). It includes:
 ## Source
 
 Built by `docs/benchmarks/note_detect_v1/build_benchmark.py` in the
-feedBack repo. Tweak the exercise list there and regenerate.
+slopsmith repo. Tweak the exercise list there and regenerate.
 """
 
 

docs/benchmarks/note_detect_v2/BENCHMARK.md

@@ -1,4 +1,4 @@
-# FeedBack Note Detect Benchmark — v2
+# Slopsmith Note Detect Benchmark — v2
 
 A slower-paced companion to v1, focused on what players can actually
 land cleanly. Half-note spacing throughout (~1.33 s between events at

docs/benchmarks/note_detect_v2/build_benchmark.py

@@ -16,11 +16,11 @@ Goals vs v1:
   technique handling is the next algorithm focus, separate from
   measuring "do basic single notes + chords score correctly?"
 
-How to run inside the feedBack container:
+How to run inside the slopsmith container:
 
     docker cp docs/benchmarks/note_detect_v2/build_benchmark.py \\
-              feedBack-web-1:/tmp/build_benchmark_v2.py
-    docker exec feedBack-web-1 python /tmp/build_benchmark_v2.py \\
+              slopsmith-web-1:/tmp/build_benchmark_v2.py
+    docker exec slopsmith-web-1 python /tmp/build_benchmark_v2.py \\
               /app/static/sloppak_cache/note_detect_benchmark_v2.sloppak
 
 After regenerating, copy the zip output to the tracked path with the
@@ -375,7 +375,7 @@ def build(out_dir: Path):
 
     manifest = {
         'title': 'Note Detect Benchmark v2',
-        'artist': 'FeedBack',
+        'artist': 'Slopsmith',
         'album': 'Note Detection Benchmark',
         'year': 2026,
         'duration': round(end_t, 3),
@@ -392,7 +392,7 @@ def build(out_dir: Path):
             {'id': 'full', 'file': 'stems/full.ogg', 'default': True},
         ],
         'benchmark': {
-            'id': 'feedBack-note-detect-benchmark',
+            'id': 'slopsmith-note-detect-benchmark',
             'version': 2,
         },
     }
@@ -466,7 +466,7 @@ def _build_zip(src_dir: Path):
 
 
 def _benchmark_readme(duration_s):
-    return f"""# FeedBack Note Detect Benchmark — v2
+    return f"""# Slopsmith Note Detect Benchmark — v2
 
 A slower-paced companion to v1, focused on what players can actually
 land cleanly. Half-note spacing throughout (~1.33 s between events at

docs/capability-domains.md

@@ -1,6 +1,6 @@
 # Capability Domains
 
-Capability domains are FeedBack-wide coordination surfaces for core, bundled first-party plugins, external plugins, and future adapters. Plugins declare the runtime surfaces they use in `plugin.json`; core declares and owns host workflows directly in the runtime. These declarations let diagnostics and support tools reason about behavior without relying on private globals.
+Capability domains are Slopsmith-wide coordination surfaces for core, bundled first-party plugins, external plugins, and future adapters. Plugins declare the runtime surfaces they use in `plugin.json`; core declares and owns host workflows directly in the runtime. These declarations let diagnostics and support tools reason about behavior without relying on private globals.
 
 ## Standards
 
@@ -16,7 +16,7 @@ Only declare `plugin-runtime-idempotent.v1` when repeated script hydration canno
 
 ## UI Contributions
 
-Legacy `nav`, `screen`, and `settings` fields still work through the existing plugin loader. PR1 keeps UI capability domains out of the runtime graph, so migrated plugins should not treat `ui.navigation`, `ui.plugin-screens`, or `settings` as active capability contracts yet. Their candidate manifest shape is reserved for a future UI-host PR:
+New plugin UI should declare stable `ui` contribution metadata so diagnostics and support tools can attribute surfaces before runtime code hydrates. The runtime host for UI placement is still promoted by a future UI-host PR, but manifests can use the candidate shape now:
 
 ```json
 {
@@ -28,25 +28,30 @@ Legacy `nav`, `screen`, and `settings` fields still work through the existing pl
 }
 ```
 
-Core continues to load legacy UI fields normally. It does not emit PR1 compatibility shim entries for UI placement or visualization `type`; the PR that promotes those domains will own their shim accounting and tests.
-
 ## Runtime Domains
 
-Declare non-UI runtime surfaces under `domains` or `runtime_domains`:
+Declare non-UI runtime surfaces under `capabilities`:
 
 ```json
 {
-  "domains": {
-    "library": { "role": "provider" }
+  "capabilities": {
+    "library": {
+      "roles": ["provider"],
+      "operations": ["query-page", "query-artists", "query-stats"],
+      "mode": "active",
+      "compatibility": "none",
+      "safety": "safe",
+      "version": 1
+    }
   }
 }
 ```
 
-If a plugin still uses `routes`, the backend loader continues to load `routes.py` normally. PR1 does not expose that legacy surface as `backend.routes`; the backend route domain is deferred until a future PR has a concrete route/provider workflow and privilege review.
+Backend route metadata should support a declared capability domain. A generic `backend.routes` domain is deferred until a future PR has a concrete route/provider workflow and privilege review.
 
 Plugins that call `context["register_library_provider"](...)` are attributed to the loading plugin id in `/api/library/providers` as `owner_plugin_id`. The browser library capability module at [static/capabilities/library.js](../static/capabilities/library.js) owns the `library` domain as a `provider-coordinator`: it refreshes `/api/library/providers`, registers the built-in `local` provider as `core.library.local`, and registers plugin-backed providers under their `owner_plugin_id` when one is known. Provider manifests should still declare the `library` capability so diagnostics and the bundled inspector can show intended relationships before the backend route code runs.
 
-Route-only external plugins that participate in library workflows without registering a browsable provider should declare requester/observer intent instead of provider ownership when they adopt this contract in their own repositories. This PR documents the generic shape only: such plugins use `library` requester/observer `requests` and `observes` declarations and do not appear as providers, owners, or separate `backend.routes` domains.
+Route-only external plugins that participate in library workflows without registering a browsable provider declare requester/observer intent instead of provider ownership when they adopt this contract in their own repositories. This PR documents the generic shape only: such plugins use `library` requester/observer `requests` and `observes` declarations and do not appear as providers, owners, or separate `backend.routes` domains.
 
 ```json
 {
@@ -63,27 +68,25 @@ Route-only external plugins that participate in library workflows without regist
 }
 ```
 
-The frontend exposes the current source list through `window.feedBack.capabilities.command('library', 'list-providers')`. Public owner commands (`list-providers`, `refresh-providers`, `get-current`, `select-provider`, `sync-song`, `inspect`) are distinct from provider operations (`query-page`, `query-artists`, `query-stats`, `tuning-names`, `get-art`, `sync-song`). The app-owned handler delegates to the existing provider registry and source selector, so plugins should not scrape the `#lib-provider` dropdown.
+The frontend exposes the current source list through `window.slopsmith.capabilities.command('library', 'list-providers')`. Public owner commands (`list-providers`, `refresh-providers`, `get-current`, `select-provider`, `sync-song`, `inspect`) are distinct from provider operations (`query-page`, `query-artists`, `query-stats`, `tuning-names`, `get-art`, `sync-song`). The app-owned handler delegates to the existing provider registry and source selector, so plugins should not scrape the `#lib-provider` dropdown.
 
 Capability declarations may include a short `description`. The bundled Capability Inspector shows that text on expanded domain owner cards; when it is omitted, the inspector falls back to a compact generated owner summary.
 
 ## Audio Graph/Session Domains
 
-The audio graph/session slice promotes four player-audio domains into the runtime graph: `audio-mix`, `audio-input`, `audio-monitoring`, and `stems`. The browser module at [static/capabilities/audio-session.js](../static/capabilities/audio-session.js) owns the active session boundary, contributes diagnostics under `feedBack.audio_session.diagnostics.v1`, and records compatibility bridge hits for legacy audio surfaces.
+The audio graph/session slice promotes four player-audio domains into the runtime graph: `audio-mix`, `audio-input`, `audio-monitoring`, and `stems`. The browser module at [static/capabilities/audio-session.js](../static/capabilities/audio-session.js) owns the active session boundary, contributes diagnostics under `slopsmith.audio_session.diagnostics.v1`, and records compatibility bridge hits for older audio surfaces.
 
-`audio-mix`, `audio-input`, and `audio-monitoring` are core-owned provider-coordinator domains. They expose bounded inspect/register/start/stop style commands, redaction-safe diagnostics, and bridge accounting for legacy fader, analyser, input, and monitoring handshakes.
+`audio-mix`, `audio-input`, and `audio-monitoring` are core-owned provider-coordinator domains. They expose bounded inspect/register/start/stop style commands, redaction-safe diagnostics, and bridge accounting for older fader, analyser, input, and monitoring handshakes.
 
 For `audio-mix`, native fader providers register mix participants with stable `participantId`, `kind`, `sourceMode`, optional `logicalFaderKey`, and `fader` metadata. The public command surface is `inspect`, `list-faders`, `get-fader-value`, `set-fader-value`, `inspect-route`, `inspect-analyser`, `register-participant`, and `unregister-participant`; provider operations are `fader.get-value`, `fader.set-value`, `route.get-current`, and `analyser.get-summary`. Providers own persistence for plugin faders and must return committed values from set operations so the player mixer can display the value that actually applied.
 
-Legacy `window.feedBack.audio.registerFader(...)` remains supported as an audio-mix compatibility bridge. The bridge registers a compatibility-backed participant, wraps legacy `getValue`/`setValue` callbacks as provider operations, and preserves `window.feedBack.audio.getFaders()` for external callers. If a native participant and a legacy fader share the same logical fader key, the native participant owns the visible control; the legacy participant is retained for diagnostics with `supersededBy` and an `overshadowed` bridge hit. Removal gates for the bridge are: native providers cover bundled mixer integrations, diagnostics show no unexpected legacy hits in normal playback, and repeated plugin hydration does not create duplicate faders.
-
-Audio-mix diagnostics live under `feedBack.audio_session.diagnostics.v1`. The `audio-mix` domain snapshot includes session state, participants, visible fader summaries, required participant-kind coverage, route summary, analyser summary, bridge hits, and bounded recent outcomes. Fader outcomes include operation name, participant id, fader id, status such as `committed`, `normalized`, `unavailable`, or `timeout`, and a bounded reason. Diagnostics must not include raw audio buffers, FFT arrays, device labels, stable hardware identifiers, secrets, or unredacted local paths; route/analyser payloads are summaries only.
+Audio-mix diagnostics live under `slopsmith.audio_session.diagnostics.v1`. The `audio-mix` domain snapshot includes session state, participants, visible fader summaries, required participant-kind coverage, route summary, analyser summary, bridge hits, and bounded recent outcomes. Fader outcomes include operation name, participant id, fader id, status such as `committed`, `normalized`, `unavailable`, or `timeout`, and a bounded reason. Diagnostics must not include raw audio buffers, FFT arrays, device labels, stable hardware identifiers, secrets, or unredacted local paths; route/analyser payloads are summaries only.
 
 For `audio-input`, native providers register source summaries with `sourceId`, `providerId`, `logicalSourceKey`, `kind`, redaction-safe label/pseudonym, `availability`, `channelSummary`, `sourceMode`, and provider operations. The public command surface is `inspect`, `list-sources`, `register-source`, `unregister-source`, `select-source`, `open-source`, and `close-source`; provider operations are `source.enumerate`, `source.describe`, `source.open`, and `source.close`. `inspect`, `list-sources`, and `select-source` are prompt-free and never open live input or call enumeration. `source.enumerate` runs only when explicitly requested by provider/user discovery. `open-source` is the permission boundary: it routes to `source.open`, attributes the requester, checks the selected source and requested channel shape, and records `handled`, `denied`, `degraded`, `failed`, `no-owner`, `no-handler`, `unsupported-command`, or `incompatible-version` outcomes.
 
 Selected input is persisted by `logicalSourceKey` when browser storage is available. If storage is unavailable, the in-memory selection remains usable for the current session and diagnostics report the storage status. Start/stop/song switches preserve selected input independently of playback transport while clearing live open sessions. Compatible requesters share one open session per logical source and channel shape; requester references are released via `close-source`, and the provider receives `source.close` only after the last requester releases.
 
-Compatibility-backed input sources should record `sourceMode: "compatibility"` plus `compatibilitySource` and, when applicable, an `audio-input.legacy-source` bridge hit. If a native provider and a compatibility-backed source share the same logical source key, the native source owns the visible source list and the compatibility source is retained in diagnostics with `supersededBy`. Removal gates for input bridges are: native providers cover bundled source discovery/open flows, diagnostics show no unexpected compatibility hits in normal playback, denied/unavailable/failure outcomes are distinguishable, repeated hydration does not create duplicate sources, and support snapshots contain no raw device labels, hardware ids, paths, secrets, live handles, buffers, samples, or waveform data.
+Compatibility-backed input sources are retained for diagnostics only when a native provider supersedes the same logical source key. Removal gates for input bridges are: native providers cover bundled source discovery/open flows, diagnostics show no unexpected compatibility hits in normal playback, denied/unavailable/failure outcomes are distinguishable, repeated hydration does not create duplicate sources, and support snapshots contain no raw device labels, hardware ids, paths, secrets, live handles, buffers, samples, or waveform data.
 
 For `audio-monitoring`, native providers register monitoring summaries with `providerId`, `logicalMonitoringKey`, redaction-safe label/pseudonym, `availability`, `sourceMode`, provider operations, `directMonitor`, and `latencySummary`. The public command surface is `inspect`, `list-providers`, `register-provider`, `unregister-provider`, `select-provider`, `start`, `stop`, and `set-direct-monitor`; provider operations are `monitoring.start`, `monitoring.stop`, `monitoring.status`, and `monitoring.set-direct-monitor`. `inspect`, `list-providers`, `select-provider`, and `monitoring.status` are prompt-free and must not open audio input or start monitoring.
 
@@ -93,25 +96,11 @@ Monitoring sessions are keyed by provider, selected source, required channel sha
 
 Direct-monitor state is user-authoritative. `set-direct-monitor` updates the user's/default preference and applies provider control to active sessions only when the provider supports it. Requester `directMonitorRequirement` values are advisory constraints: when they conflict with the user's preference or provider support, the requester/session is marked degraded or unsupported, but the stored user/default preference is not changed.
 
-Compatibility-backed monitoring providers should record `sourceMode: "compatibility"` plus `compatibilitySource` (which becomes the bridge id, defaulting to `audio-monitoring.legacy-provider` when unset) and, when applicable, the `audio-monitoring.audio-barrier` startup-barrier bridge hit. If a native provider and compatibility-backed provider share a logical monitoring key, the native provider owns the visible provider list and the compatibility provider is retained in diagnostics with `supersededBy`. Removal gates for monitoring bridges are: native providers cover bundled start/stop/status/direct-monitor flows, normal playback shows no unexpected legacy hits, background requesters cannot silently start live monitoring, repeated hydration does not duplicate providers or sessions, and support snapshots contain no raw device labels, hardware ids, paths, secrets, live handles, buffers, samples, waveform data, recordings, or provider-private payloads.
+Compatibility-backed monitoring providers are retained for diagnostics only when a native provider supersedes the same logical monitoring key. Removal gates for monitoring bridges are: native providers cover bundled start/stop/status/direct-monitor flows, normal playback shows no unexpected compatibility hits, background requesters cannot silently start live monitoring, repeated hydration does not duplicate providers or sessions, and support snapshots contain no raw device labels, hardware ids, paths, secrets, live handles, buffers, samples, waveform data, recordings, or provider-private payloads.
 
 `stems` is different: `core.audio.session` is a coordinator, not the semantic owner of stem playback. The Stems plugin, or another active stem provider, remains the provider/owner of actual stem state, mute/restore mechanics, and per-song availability. The session coordinator records the active provider via `registerStemOwner(...)`, brokers claim/override/orphan diagnostics, and returns `no-owner` when no stem provider is available.
 
-New bundled audio code should use the session host or native capability dispatch instead of adding new globals, private stem-state reads, direct analyser ownership, or plugin-specific handshakes. Existing legacy paths remain supported through named compatibility bridges until their migration notes and removal gates are satisfied.
-
-## Audio Effects Domain
-
-The audio-effects slice promotes `audio-effects` as a core-owned provider-coordinator domain implemented by [static/capabilities/audio-effects.js](../static/capabilities/audio-effects.js). The host owns provider selection, compatible executor selection, route state, fallback accounting, redaction-safe diagnostics, and the constrained chain-plan schema. Providers do not call executors. Provider code proposes plans and, for execution requests, returns a provider-private trusted asset map to the host; the host immediately hands that private request to a compatible executor such as trusted Desktop native audio or NAM Tone's browser/WASM executor.
-
-The public command surface is `inspect`, `list-providers`, `list-executors`, `register-provider`, `unregister-provider`, `register-executor`, `unregister-executor`, `select-chain`, `resolve-plan`, `load-plan`, `inspect-route`, `list-mappings`, `upsert-mapping`, `delete-mapping`, `activate-mapping`, `clear-active-mapping`, `bypass`, `restore`, `fallback`, `activate-segment`, `set-stage-bypass`, `set-stage-parameter`, and `record-bridge-hit`. Provider operations are `chain.resolve`, `chain.inspect`, `mapping.list`, `mapping.upsert`, `mapping.delete`, `mapping.activate`, `mapping.clear-active`, `segment.activate`, `stage.set-bypass`, `stage.set-parameter`, `route.bypass`, and `route.restore`; executor operations are `loadChainPlan`, `activateSegment`, `setStageBypass`, and `setStageParameter`. Fresh chain selection and route bypass/restore require `authorization: "user-action"` or `authorization: "restore-selection"`; physical loading through `load-plan` requires `authorization: "user-action"`, `authorization: "restore-selection"`, or `authorization: "playback-session"`. Background requesters may inspect the current route and resolve an already selected compatible provider.
-
-Core also owns the durable public mapping index at `/api/audio-effects/mappings`. A mapping answers "for this song/tone, this provider has an addressable effect plan"; it does not contain the provider's preset or chain data. Rows are keyed by `song_key + tone_key + provider_id`, carry an opaque `provider_ref`, and may be marked as the active mapping for that song/tone. Providers CRUD their own rows through the audio-effects host and resolve `provider_ref` inside their own storage when `chain.resolve` runs. This lets NAM Tone and Rig Builder coexist for the same song/tone while core owns arbitration and fallback order. `song_key` should be the playback domain's redaction-safe settings key when available; `filename` is optional legacy/debug context for migration and display.
-
-Providers register stable `providerId`, `pluginId`, `routeKey`, priority, availability, source mode, operations, and operation handlers. Executors register stable `executorId`, `pluginId`, `routeKey`, priority, availability, source mode, supported provider ids, supported stage kinds, optional maximum stage count, operations, and handlers. The host chooses the highest-priority enabled provider for a route unless the caller requests a specific provider, then chooses the highest-priority compatible executor for that provider and resolved plan. Compatibility means both provider-compatible and plan-compatible: a browser/WASM NAM executor can advertise `providerIds: ["nam-tone"]`, `supportedKinds: ["nam", "ir"]`, and `maxStages: 2`, so it will not be asked to execute a Rig Builder VST/full-chain plan. If a selected provider has no compatible executor and the caller supplies a fallback provider, the host may fall back to that provider; if the caller explicitly requested the original provider, the host reports `unavailable` instead of silently changing providers. The initial default route is `desktop-main`, matching the desktop native executor path planned for full-chain NAM/IR/VST playback while still allowing browser executors for non-Desktop runtimes.
-
-`chain.resolve` returns schema `feedBack.audio_effects.chain_plan.v1`. A valid plan includes `planId`, `routeKey`, `providerId`, `stages`, optional `segments`, and optional redaction-safe summaries. Each stage exposes only stable opaque `stageId`, `kind` (`nam`, `ir`, `vst`, `utility`, or `bypass`), `role` (`pre-pedal`, `amp`, `cab`, `rack`, `master-pre`, etc.), opaque `assetRef`, optional opaque `stateRef`, bypass state, gain summary, and safe summary metadata. Raw file paths, URLs, model filenames, IR filenames, VST state blobs, native preset JSON, callbacks, handles, DOM nodes, audio buffers, samples, and waveform data are rejected or omitted.
-
-Diagnostics live under `feedBack.audio_effects.diagnostics.v1`. The snapshot includes provider summaries, executor summaries, route summaries, bridge hits, bounded recent outcomes, limits, and redaction notes. It intentionally omits full chain plans, stage asset references, provider-private mapping payloads, raw filenames, and song keys; diagnostics should explain which provider/executor/route failed without leaking local library structure or licensed asset names. Legacy NAM Tone/Rig Builder fetch interception, direct Desktop `loadPreset` calls, legacy tone controls, old `nam_tone.db` `tone_mappings` access, and MIDI/external effect handoffs are attributed through `audio-effects.legacy-nam-routing`, `audio-effects.legacy-native-load`, `audio-effects.legacy-tone-controls`, `audio-effects.legacy-tone-db`, and `audio-effects.legacy-midi-amp` bridge records while providers migrate.
+New bundled audio code should use the session host or native capability dispatch instead of adding new globals, private stem-state reads, direct analyser ownership, or plugin-specific handshakes.
 
 ## Playback Control Plane
 
@@ -119,51 +108,7 @@ The playback slice promotes `playback` as a core-owned command domain implemente
 
 `static/app.js` remains the transport data plane. It registers a private playback adapter that can start songs, pause/resume/stop, seek, and manage loops, but the capability snapshot never exposes the `<audio>` element, JUCE player object, raw audio buffers, native route handles, samples, waveforms, recordings, local file paths, or URL payloads. Exported diagnostics use pseudonymous `target-*` ids for arrangement-scoped identity and hashed `settings-*` keys for per-song plugin settings; the local Capability Inspector may show visible title, artist, and arrangement labels for the active song.
 
-Legacy playback surfaces remain supported during migration and are attributed through bridges such as `playback.window-play-song`, `playback.song-events`, `playback.window-feedBack-transport`, `playback.loop-api`, and native route handoff records. Fresh audible `start` commands require `authorization: "user-action"`; background requesters may inspect or control an existing session, but user-priority pause/stop decisions block lower-priority automation until a user action resumes or starts a new session.
-
-## Progression Domain
-
-The progression slice (spec 010) promotes `progression` as a core-owned command domain implemented by [static/v3/progression-core.js](../static/v3/progression-core.js). Core owns the player's mastery rank (onboarding calibration + instrument-path levels), the challenge/quest engine, the Decibels wallet, and the cosmetics shop; all definitions are bundled content under `data/progression/` so new paths, levels, challenges, quests, and shop items are JSON edits, never code.
-
-The public command surface is `inspect`, `record-event`, `list-shop`, `buy-item`, and `equip-item`. `record-event` accepts only whitelisted externally-postable event types (`minigame_run` in v1); `song_completed` is server-derived inside `/api/stats` so scored-session authority stays in one place and is denied at this surface. `buy-item` and `equip-item` require `authorization: "user-action"`. Backend plugins use the symmetric plugin-context hook `record_progression_event` (the minigames hub reports runs through it), which trusts backend code and skips the HTTP whitelist.
-
-The domain emits `challenge-completed`, `quest-completed`, `path-level-up`, `rank-changed`, `db-changed`, `calibration-completed`, and `cosmetic-equipped` on the capability surface, mirrored as `progression:*` events on `window.feedBack` for non-capability consumers. Diagnostics live under `feedBack.progression.diag.v1` and contain content-load warnings, rank/path-level/quest counts, and wallet totals only — no song filenames or display names.
-
-Decibels are earned exclusively by playing (songs, minigame runs, quest rewards); there is no real-money acquisition path and none may be added. The wallet tracks spend separately from the monotonic lifetime-earned total, so per-source XP resets and `db_earned` goals stay correct. A deferred release slice adds a `contributor` role so plugins can ship their own challenge/quest content (e.g. a drums plugin contributing drums challenges); content stays core-bundled until then.
-
-## Visualization Domain
-
-The visualization slice (cap:6) promotes `visualization` as a core-owned provider-coordinator implemented by [static/capabilities/visualization.js](../static/capabilities/visualization.js). Viz plugins are providers of the highway renderer surface; the core picker/auto-match machinery in `static/app.js` stays the selection workflow and attributes every renderer change into the domain.
-
-The public command surface is `inspect`, `list-providers`, `select-renderer`, and `clear-renderer`. Selection delegates to the existing picker (`setViz`) so localStorage persistence, WebGL2 gating, and fallback semantics have exactly one implementation. The domain emits `providers-refreshed`, `renderer-changed` (with a `source` of `auto-match`, `user-select`, `fallback`, or `command:<requester>`), `renderer-ready`, and `renderer-failed`.
-
-Provider discovery is still the legacy surface — `type: "visualization"` manifests populate the picker and `window.feedBackViz_*` factory globals carry the renderer contract — and both are registered as compatibility shims (`visualization:type-visualization-manifest`, `visualization:window.feedBackViz_*`) with hit accounting, so the Inspector shows exactly how much of the domain still rides the bridge. Plugins migrate by declaring a `visualization` provider capability in their manifests; the renderer factory contract (`init`/`draw`/`resize`/`destroy`, `contextType`, `matchesArrangement`) is unchanged.
-
-**Per-instance provider settings (#849).** A provider may declare a `settings` array on its `visualization` capability — generic control descriptors (`{ key, label, type: "toggle" | "range" | "select", default, min/max/step, options }`) the capability-pipelines schema validates on *any* domain (the field lives on the shared `capabilityDeclaration`, not a visualization-only spot — see `docs/plugin-manifest.schema.json`). Descriptors flow through the **generic participant model**: the backend validates them for `/api/plugins` (`plugins/__init__.py`), `static/capabilities.js` normalizes + preserves them on the registered participant (so generic `inspect('visualization')` carries them), and the visualization owner reads them back from the participant by id — no app.js/picker side channel. They surface in the `list-providers` snapshot (each provider's `settings`, deep-frozen) plus a `provider_policy.hasSettings` flag in diagnostics, so a consuming host — splitscreen's per-panel control popover — can render the controls generically without per-plugin hardcoding. The visualization domain's **apply contract**: a provider that declares `settings` MUST implement `applySetting(key, value)` on its renderer instance (the host calls it on the specific per-panel instance, which is inherently per-panel — no canvas→panel resolution, no shared global keys); `getSetting(key)` is optional (the host falls back to the declared `default`). The host owns persistence. **This core slice lands the declarative surface + participant plumbing only** — no bundled provider declares `settings` yet (`highway_3d` still ships the legacy `factory.panelControls` static). The `highway_3d` migration and the splitscreen generic consumer are the remaining #849 follow-ups.
-
-Diagnostics live under `feedBack.visualization_capability.v1` and contain provider ids/labels/context types, the active renderer id and its selection source, the last auto-match outcome (resolved id + whether any predicate claimed the song), and the last failure (provider id + reason) — never song filenames, titles, or arrangement names. Per-panel selection (splitscreen #90) and per-panel provider settings (#849) are tracked follow-ups; the domain currently models the primary highway surface.
-
-## Note-Detection Domain
-
-The note-detection slice (spec 009, issues #727/#728) promotes `note-detection` as a core-owned provider-coordinator implemented by [static/capabilities/note-detection.js](../static/capabilities/note-detection.js). Doctrine per [specs/009-note-detection-domain/spec.md](../specs/009-note-detection-domain/spec.md): the domain exposes detection PRIMITIVES through requester-owned, context-scoped bindings — a monophonic pitch estimate and a polyphonic "is this note set ringing now?" verification — and consumers own all judgment semantics (hit windows, streaks, accuracy, tiers). Hit/miss/verdict results flow through the domain as observability events, never as domain-owned scoring.
-
-The public command surface is `inspect`, `register-provider`, `unregister-provider`, `open-binding`, `close-binding`, `set-target`, and `clear-target`. Providers declare a kind — `midi` (a digital instrument producing exact verdicts, e.g. the keys highway's Web-MIDI input), `engine` (the desktop JUCE verifier), or `js` (the browser harmonic-comb / YIN fallback) — and the primitives they serve (`pitch.estimate`, `verify.target`). Each binding carries its requester's own redacted context summary (arrangement kind, string count, capo, MIDI range), independent of whatever song the host highway has loaded; concurrent bindings never perturb one another (spec 009 FR-003). With no provider registered, `open-binding` reports `unavailable` — consumers degrade, never block.
-
-The legacy chart-coupled surface — `highway.setNoteStateProvider(fn)`, the single-global-detector path spec 009 retires — keeps working unchanged and is wrapped for compatibility-shim hit accounting (`note-detection:highway.setNoteStateProvider`). Migrating the chart `note_detect` consumer, Step Mode verify, minigames YIN scoring, and the `setVerifyTarget` bridge onto real bindings — and wiring per-binding tuning contexts into the engine verifier — is the remainder of the spec-009 slice and lands behind the Spec 003 migration gate.
-
-Diagnostics live under `feedBack.note_detection_capability.v1` and contain provider ids/labels/kinds, binding summaries (requester, provider, redacted context, target size), availability, and the last bounded outcome (event, binding, provider, MIDI number, hit flag) — never raw audio buffers, sample data, device labels, or song identity.
-
-## MIDI-Input Domain
-
-The MIDI-input slice (spec 012, issues #873/#880) promotes `midi-input` as a **core-owned** provider-coordinator implemented by [static/capabilities/midi-input.js](../static/capabilities/midi-input.js) — the MIDI analog of `audio-input`. It is deliberately separate from `audio-input` (whose source/`open` contract is audio-frame-centric: channel shapes, sample buffers) because MIDI carries discrete messages, not audio; and it is **not** owned by any feature plugin, so the device-access boundary outlives the input-setup wizard (exactly as `audio-input` is `core.audio.session`-owned). Consumers — the `input_setup` onboarding wizard, the `piano`/keys and `drums` plugins, and (as a follow-up, #881) note-detection's Web-MIDI provider — converge here on ONE device-access boundary: one permission prompt, one source list, one redaction boundary, retiring private per-plugin `navigator.requestMIDIAccess()` calls.
-
-Native providers register source summaries with `providerId`, a stable `sourceId`, a derived redaction-safe `logicalSourceKey` (`providerId::sourceId`), `kind: "midi"`, a label, and `availability`. The public command surface is `inspect`, `list-sources`, `discover`, `select-source`, `open-source`, and `close-source`; provider operations are `source.enumerate`, `source.describe`, `source.open`, and `source.close`. `inspect`, `list-sources`, and `select-source` are prompt-free and never request MIDI access. Unlike audio (where `getUserMedia` gates labels and `open-source` is the prompt), Web-MIDI's `requestMIDIAccess()` gates the whole input list, so **`discover` is the permission boundary** and records `denied`/`unavailable` outcomes; `open-source` then attaches a shared listener session and never re-prompts.
-
-Selected input is persisted by `logicalSourceKey` (`feedBack.midiInput.selectedLogicalSourceKey`) when browser storage is available. Compatible requesters share one open session per source; each later calls `close-source`, and the provider receives `source.close` only after the last requester releases. Live MIDI message delivery (for the "play a note / hit a pad" calibration check) is exposed to in-page consumers through the public `window.feedBack.midiInput` session handle only — never as raw capability events or diagnostics.
-
-The reserved `midi-control` domain is the planned **sibling** for control mappings (CC/pitchbend/note → action routing) and will consume `midi-input` for device access (spec 013 / #882); this slice carves the device control plane out so `midi-control` can stay mappings-only. `midi-control` stays RESERVED (documentation-only) until a concrete mapping consumer + tests exist, per the future-domain governance.
-
-Diagnostics live under `feedBack.midi_input.diagnostics.v1` and contain provider ids, source ids/keys/kinds/availability, the selected key, and open-session keys — **device labels are redacted** and no raw MIDI messages are ever included.
+Fresh audible `start` commands require `authorization: "user-action"`; background requesters may inspect or control an existing session, but user-priority pause/stop decisions block lower-priority automation until a user action resumes or starts a new session.
 
 ## Capability Roles
 
@@ -185,23 +130,23 @@ Use capability declarations for provider/requester/observer relationships:
 
 Future app-level workflows can then express intent through capability domains instead of hard-coding plugin-private implementation details.
 
-Core registers manifest capability declarations from `/api/plugins` before plugin scripts hydrate. Runtime owners can then re-register the same participant with command handlers, event handlers, and current availability state. The merged participant view is visible through `window.feedBack.capabilities.snapshotDiagnostics()` and `getDiagnostics()`.
+Core registers manifest capability declarations from `/api/plugins` before plugin scripts hydrate. Runtime owners can then re-register the same participant with command handlers, event handlers, and current availability state. The merged participant view is visible through `window.slopsmith.capabilities.snapshotDiagnostics()` and `getDiagnostics()`.
 
 Core domains include review metadata in diagnostics:
 
-- `active`: wired to current FeedBack behavior and expected to work as an integration point.
+- `active`: wired to current Slopsmith behavior and expected to work as an integration point.
 - `diagnostic`: support/inspection-only runtime surfaces.
 
-PR1 includes only the delivered domains listed in [capability-roadmap.md](capability-roadmap.md): `pipeline`, `diagnostics`, and `library`. The follow-up audio graph/session slice promotes `audio-mix`, `audio-input`, `audio-monitoring`, and a coordinated `stems` surface. The playback slice promotes `playback` as an active transport control plane. The audio-effects slice promotes provider-selected effect-chain planning while leaving physical processor loading to compatible executors such as trusted Desktop native audio or a browser/WASM executor. The visualization slice promotes `visualization` as the highway renderer provider-coordinator, and the note-detection slice (spec 009) promotes `note-detection` as the detection-binding control plane. Backend routes, app UI, settings, and other hardware-facing domains remain documented in the roadmap and safety matrix until their own host workflow/provider slice exists.
+PR1 includes only the delivered domains listed in [capability-roadmap.md](capability-roadmap.md): `pipeline`, `diagnostics`, and `library`. The follow-up audio graph/session slice promotes `audio-mix`, `audio-input`, `audio-monitoring`, and a coordinated `stems` surface. The playback slice promotes `playback` as an active transport control plane. Backend routes, app UI, settings, visualization, note-detection, and other hardware-facing domains remain documented in the roadmap and safety matrix until their own host workflow/provider slice exists.
 
-Capability metadata is versioned by the `capability-pipelines.v1` standard. Invalid roles, commands, operations, requests, observes, emits, events, owner kinds, compatibility modes, ownership policies, safety classes, or version fields are excluded from the capability graph and surfaced through `capability_validation_warnings`; legacy plugin fields continue to load through their existing app paths. Plugins that declare a future `capability-pipelines` version are reported through `capability_unsupported_versions` and their runtime handlers are marked incompatible.
+Capability metadata is versioned by the `capability-pipelines.v1` standard. Invalid roles, commands, operations, requests, observes, emits, events, owner kinds, compatibility modes, ownership policies, safety classes, or version fields are excluded from the capability graph and surfaced through `capability_validation_warnings`. Plugins that declare a future `capability-pipelines` version are reported through `capability_unsupported_versions` and their runtime handlers are marked incompatible.
 
 `diagnostics` and `pipeline` are adjacent support domains. `diagnostics` is the read-only snapshot/export surface: `snapshot` returns the redaction-safe state used by support bundles and the Capability Inspector. `pipeline` is the graph operations surface: `inspect`, `validate`, and `participant.set-enabled` operate on the capability graph itself and emit graph lifecycle events such as `resolved`, `runtime.validated`, and `participant.state-changed`.
 
 Requesters should use the public claim/dispatch/release flow instead of mutating another plugin's globals:
 
 ```js
-const api = window.feedBack.capabilities;
+const api = window.slopsmith.capabilities;
 const releaseClaim = api.claim({ capability: 'example.plugin-domain', claimId: 'example.automation-active', requester: 'example_requester' });
 await api.dispatch({
   capability: 'example.plugin-domain',
@@ -229,7 +174,7 @@ Owner participants use a `kind` that describes how the domain is coordinated:
 - `diagnostic`: read-only support and inspector surfaces.
 - `privileged`: command execution needs an explicit enforcement plan before shipping.
 
-Legacy `ownership` remains accepted in manifests for compatibility and diagnostics, but new domains should prefer `kind` plus participant roles. Ownership is derived for core owners where possible: `provider-coordinator` behaves like a multi-provider domain, diagnostics are diagnostic-only, privileged owners are privileged, and command/event owners are exclusive by default.
+New domains should prefer `kind` plus participant roles. Ownership is derived for core owners where possible: `provider-coordinator` behaves like a multi-provider domain, diagnostics are diagnostic-only, privileged owners are privileged, and command/event owners are exclusive by default.
 
 The compatibility ownership vocabulary remains:
 
@@ -244,9 +189,9 @@ Dispatch results use explicit outcomes: `handled`, `transformed`, `denied`, `fai
 
 ## Deferred Core Adapters
 
-UI placement and settings contributions are real FeedBack surfaces, but they are not PR1 capability contracts (visualization is active as of the cap:6 slice; note-detection as of the spec-009 slice). Audio mixer/session domains are active as of the audio graph/session slice, playback is active as of the playback control-plane slice, and audio-effects is active as a provider/route/chain-plan coordinator; plugins should keep using current documented APIs for remaining areas until the corresponding domain PR ships the host workflow, command/event contract, compatibility shims, diagnostics fields, and tests.
+UI placement, settings contributions, visualization, and note-detection are real Slopsmith surfaces, but they are not PR1 capability contracts. Audio mixer/session domains are active as of the audio graph/session slice, and playback is active as of the playback control-plane slice. For remaining areas, document the capability gap and avoid adding new private integration surfaces until the corresponding domain PR ships the host workflow, command/event contract, diagnostics fields, and tests.
 
-The library provider workflow is the PR1 core adapter and is implemented natively as the `library` capability module. Provider refresh, selection, and sync run through `library` owner commands; backend provider registration remains the way providers enter the library registry, and the browser module turns that registry into provider participants. The app event bus continues to dispatch local `window.feedBack` events for legacy listeners; playback now mirrors song transport, route, seek, and loop lifecycle into `playback`, and visualization attributes renderer selection/failure, while navigation, note, and route-only surfaces remain outside capability domains until their own slices land.
+The library provider workflow is the PR1 core adapter and is implemented natively as the `library` capability module. Provider refresh, selection, and sync run through `library` owner commands; backend provider registration remains the way providers enter the library registry, and the browser module turns that registry into provider participants. Playback mirrors song transport, route, seek, and loop lifecycle into `playback`, while navigation, note, visualization, route-only, and highway rendering surfaces remain outside capability domains until their own slices land.
 
 The direct `window.highway` object remains the renderer data plane. Per-frame reads such as notes, chords, beats, and renderer hooks should not be moved behind asynchronous capability commands until there is a dedicated chart/render facade.
 
@@ -254,13 +199,13 @@ The direct `window.highway` object remains the renderer data plane. Per-frame re
 
 Large management surfaces should prefer plugin-owned UI over crowding normal Settings. First-party management plugins can contribute screens and settings panels while core keeps shared services and diagnostics contracts centralized.
 
-The bundled Capability Inspector plugin is the support surface for the current graph. It reads `window.feedBack.capabilities.snapshotDiagnostics()`, filters by domain, and summarizes manifest participants, runtime participants, conflicts, unsupported versions, safety classes, expected legacy event surfaces, and compatibility shim hits without rendering raw runtime objects. Domains are grouped in review order: application/library, player/audio runtime, plugin-defined surfaces, then capability runtime. In the all-domains view, each domain starts collapsed with a domain-specific icon plus compact summary badges for participant-lane count, endpoint count, observed links, shimmed links, and status; badge labels live in tooltips/ARIA labels so the header stays scannable. Clicking the domain label expands or collapses the domain, opening the same graph view used by the single-domain filter. The graph places owner details and right-aligned command/event groups on the left, with short owner descriptions bottom-aligned as the final part of that pane. Participant usage is grouped the same way on the right, with observed or shimmed links between border-aligned endpoint ports. In multi-provider domains, links to provider participants use provider-family colors: purple for owner-to-provider command delegation and a lighter violet for provider events. Provider participants, including `library` sources, stay on the right lane and show a provider icon in their header. Headers show role-aware core/non-core origin badges such as Core owner, Core provider, or Non-core participant; owner headers place the origin badge directly after the owner icon, and the built-in local library provider is marked as core-origin. Observer and requester roles are implied by the command/event links rather than separate header badges. Participant cards are shown only when the plugin or runtime source has visible command or event usage for the current graph filter; domains with no such usage show zero participants, and attribution-only shims with no matching endpoint stay out of the lane. Command and event groups can collapse; when collapsed, all links for that side and group converge on the single group port. Hovering a participant, endpoint, or command/event group emphasizes the matching links and dims unrelated links; owner-side labels outside the current focus de-emphasize so the active source endpoints are easy to track. Expanded domain graphs progressively enhance to Cytoscape.js overlays that route bezier links between measured DOM endpoint ports, while keeping the HTML lanes as the fallback and readable data surface. Its Plugins-menu entry is hidden by default; enable **Capability Inspector → Show in Plugins menu** from Settings when reviewing or debugging capability behavior.
+The bundled Capability Inspector plugin is the support surface for the current graph. It reads `window.slopsmith.capabilities.snapshotDiagnostics()`, filters by domain, and summarizes manifest participants, runtime participants, conflicts, unsupported versions, safety classes, expected compatibility event surfaces, and compatibility shim hits without rendering raw runtime objects. Domains are grouped in review order: application/library, player/audio runtime, plugin-defined surfaces, then capability runtime. In the all-domains view, each domain starts collapsed with a domain-specific icon plus compact summary badges for participant-lane count, endpoint count, observed links, shimmed links, and status; badge labels live in tooltips/ARIA labels so the header stays scannable. Clicking the domain label expands or collapses the domain, opening the same graph view used by the single-domain filter. The graph places owner details and right-aligned command/event groups on the left, with short owner descriptions bottom-aligned as the final part of that pane. Participant usage is grouped the same way on the right, with observed or shimmed links between border-aligned endpoint ports. In multi-provider domains, links to provider participants use provider-family colors: purple for owner-to-provider command delegation and a lighter violet for provider events. Provider participants, including `library` sources, stay on the right lane and show a provider icon in their header. Headers show role-aware core/non-core origin badges such as Core owner, Core provider, or Non-core participant; owner headers place the origin badge directly after the owner icon, and the built-in local library provider is marked as core-origin. Observer and requester roles are implied by the command/event links rather than separate header badges. Participant cards are shown only when the plugin or runtime source has visible command or event usage for the current graph filter; domains with no such usage show zero participants, and attribution-only shims with no matching endpoint stay out of the lane. Command and event groups can collapse; when collapsed, all links for that side and group converge on the single group port. Hovering a participant, endpoint, or command/event group emphasizes the matching links and dims unrelated links; owner-side labels outside the current focus de-emphasize so the active source endpoints are easy to track. Expanded domain graphs progressively enhance to Cytoscape.js overlays that route bezier links between measured DOM endpoint ports, while keeping the HTML lanes as the fallback and readable data surface. Its Plugins-menu entry is hidden by default; enable **Capability Inspector → Show in Plugins menu** from Settings when reviewing or debugging capability behavior.
 
 ## Diagnostics Contract
 
-Capability diagnostics use schema `feedBack.capabilities.diagnostics.v1`. Snapshots are redaction-safe and capped at 64 KB by trimming older `recentDecisions` first while preserving current participants, active or orphaned claims, conflicts, domain review metadata, shim summaries, safety notes, and unsupported-version reports. Server diagnostics bundles include plugin manifest capability metadata, validation warnings, unsupported-version metadata, and compatibility shim summaries.
+Capability diagnostics use schema `slopsmith.capabilities.diagnostics.v1`. Snapshots are redaction-safe and capped at 64 KB by trimming older `recentDecisions` first while preserving current participants, active or orphaned claims, conflicts, domain review metadata, shim summaries, safety notes, and unsupported-version reports. Server diagnostics bundles include plugin manifest capability metadata, validation warnings, unsupported-version metadata, and compatibility shim summaries.
 
-Compatibility shim entries include `shimId`, `source`, `capability`, `legacySurface`, `status`, `reason`, and optional hit fields. A shim with `hitCount > 0` means legacy behavior was observed, not merely declared. The `library` domain no longer uses compatibility shims for provider registration or source selection; provider attribution comes from `owner_plugin_id` and runtime provider participants. Future domains should add expected shim entries only in the PR that implements their actual legacy bridge.
+Compatibility shim entries include `shimId`, `source`, `capability`, `legacySurface`, `status`, `reason`, and optional hit fields. A shim with `hitCount > 0` means compatibility behavior was observed, not merely declared. The `library` domain no longer uses compatibility shims for provider registration or source selection; provider attribution comes from `owner_plugin_id` and runtime provider participants. Future domains should add expected shim entries only in the PR that implements their actual compatibility bridge.
 
 ## Expected Future Domains
 
@@ -272,25 +217,36 @@ Release slices should stay reviewable. The domain-level roadmap, PR1 domain set,
 
 Future privileged domains must state user value, included and excluded commands, safety class, diagnostics fields, failure recovery, and tests proving disabled or incompatible participants cannot execute handlers before implementation begins.
 
-## Rehydration Pattern
+## Runtime Idempotency Pattern
 
-Plugins that wrap shared functions such as `window.playSong` or `window.showScreen` should store wrapper state on a stable `window.__feedBack...Hooks` object. Re-running the script should replace the implementation object and return before installing another wrapper.
+Plugins that declare `plugin-runtime-idempotent.v1` must tolerate repeated script hydration without duplicating participants, listeners, timers, DOM roots, jobs, media nodes, or diagnostics contributors. Use stable ids and replace the current implementation behind the participant instead of registering a second copy.
 
 ```js
-const hookState = window.__feedBackMyPluginHooks || (window.__feedBackMyPluginHooks = {});
-hookState.impl = { afterPlaySong(filename) { /* current implementation */ } };
-if (hookState.installed) return;
-hookState.installed = true;
-hookState.basePlaySong = window.playSong;
-window.playSong = async function(filename, arrangement) {
-  await hookState.basePlaySong.call(this, filename, arrangement);
-  hookState.impl?.afterPlaySong?.(filename, arrangement);
+const runtime = window.__slopsmithMyPluginRuntime || (window.__slopsmithMyPluginRuntime = {});
+runtime.impl = {
+  async inspect() {
+    return { ready: true };
+  },
 };
+
+if (!runtime.registered) {
+  runtime.registered = true;
+  window.slopsmith.capabilities.registerParticipant('my_plugin.runtime', {
+    'example.plugin-domain': {
+      roles: ['provider'],
+      commands: ['inspect'],
+      handlers: {
+        inspect: () => runtime.impl.inspect(),
+      },
+      runtime: true,
+    },
+  });
+}
 ```
 
 ## Validation Commands
 
-From the `feedBack/` directory:
+From the `slopsmith/` directory:
 
 ```bash
 node --check static/app.js

docs/capability-recipes.md

@@ -1,6 +1,6 @@
 # Capability Authoring Recipes
 
-Use these examples as small manifest fragments when migrating plugin-facing integrations to capability pipelines. The capability model is system-wide; these recipes focus on plugin manifests because core-owned domains are registered by FeedBack itself. Each example is intentionally complete enough to pass the loader contract in [plugin-manifest.schema.json](plugin-manifest.schema.json).
+Use these examples as small manifest fragments when migrating plugin-facing integrations to capability pipelines. The capability model is system-wide; these recipes focus on plugin manifests because core-owned domains are registered by Slopsmith itself. Each example is intentionally complete enough to pass the loader contract in [plugin-manifest.schema.json](plugin-manifest.schema.json).
 
 > **Self-hosted CSS?** If your plugin uses Tailwind classes core doesn't ship (notably arbitrary values like `text-[11px]`), declare a `styles` key and bundle your own preflight-off stylesheet — see [plugin-styles.md](plugin-styles.md). That is separate from the capability-pipeline recipes below.
 
@@ -100,7 +100,7 @@ A plugin that registers a remote client or generated library source declares its
 
 ## Library Requester And Observer
 
-A route-only wrapper that uses the library capability without registering a browsable provider should declare requester/observer intent instead of provider ownership. This is a generic manifest shape for external plugins to adopt in their own repositories; it does not make the wrapper part of this PR's delivered domain set.
+A route-only wrapper that uses the library capability without registering a browsable provider declares requester/observer intent instead of provider ownership. This is a generic manifest shape for external plugins to adopt in their own repositories; it does not make the wrapper part of this PR's delivered domain set.
 
 ```json
 {
@@ -124,7 +124,7 @@ A route-only wrapper that uses the library capability without registering a brow
 
 ## Audio Mix Fader Provider
 
-Existing plugins can keep using `window.feedBack.audio.registerFader(spec)` while migrating. The compatibility bridge records the fader as an `audio-mix` participant. New bundled code should prefer a native participant declaration plus the audio-session helper once available in its integration point.
+Existing plugins can keep using `window.slopsmith.audio.registerFader(spec)` while migrating. The compatibility bridge records the fader as an `audio-mix` participant. New bundled code should prefer a native participant declaration plus the audio-session helper once available in its integration point.
 
 ```json
 {
@@ -147,121 +147,9 @@ Existing plugins can keep using `window.feedBack.audio.registerFader(spec)` whil
 
 Native audio-mix fader providers should register a stable participant id and fader id, return the committed value from every set operation, and settle get/set operations within two seconds. The player mixer displays the committed value rather than the raw requested value. If the fader is temporarily unavailable, keep the participant registered with unavailable/disabled state so the mixer can render a disabled control and diagnostics can explain why it cannot be changed.
 
-During migration, a plugin may still call `window.feedBack.audio.registerFader(spec)`. Core maps that legacy fader into a compatibility-backed audio-mix participant and records bridge hits. If a native participant and a legacy fader represent the same logical source, the native participant owns the visible control and the legacy path is reported as compatibility-backed/overshadowed.
-
-## Audio Effects Provider
-
-Plugins that can provide guitar/bass processing chains should declare `audio-effects` as a provider and register at runtime with `window.feedBack.audioEffects.registerProvider(...)`. The provider returns opaque chain plans; it must not expose local filenames, URLs, native preset JSON, VST state blobs, or raw handles through diagnostics or public route state.
-
-```json
-{
-  "id": "rig_builder",
-  "name": "Rig Builder",
-  "standards": ["capability-pipelines.v1", "plugin-runtime-idempotent.v1"],
-  "capabilities": {
-    "audio-effects": {
-      "roles": ["provider"],
-      "operations": ["chain.resolve", "chain.inspect", "segment.activate", "stage.set-bypass", "stage.set-parameter"],
-      "events": ["provider-registered", "route-selected", "plan-resolved", "changed", "fallback", "bridge-hit"],
-      "mode": "active",
-      "compatibility": "shim-allowed",
-      "safety": "sensitive",
-      "version": 1
-    }
-  }
-}
-```
-
-```js
-const effects = window.feedBack && window.feedBack.audioEffects;
-effects.registerProvider({
-  providerId: 'rig-builder',
-  pluginId: 'rig_builder',
-  routeKey: 'desktop-main',
-  priority: 40,
-  operations: ['chain.resolve', 'segment.activate', 'stage.set-bypass', 'stage.set-parameter'],
-  operationHandlers: {
-    'chain.resolve': request => ({
-      outcome: 'handled',
-      plan: {
-        schema: 'feedBack.audio_effects.chain_plan.v1',
-        planId: 'song-tone-plan',
-        routeKey: request.routeKey,
-        providerId: 'rig-builder',
-        stages: [
-          { stageId: 'amp', kind: 'nam', role: 'amp', assetRef: 'rig-builder:asset:amp-main' },
-          { stageId: 'cab', kind: 'ir', role: 'cab', assetRef: 'rig-builder:asset:cab-main' }
-        ],
-        segments: [{ segmentId: 'base', stageIds: ['amp', 'cab'] }],
-        summary: { stageCount: 2 }
-      }
-    })
-  }
-});
-```
-
-User-facing controls should dispatch through the domain instead of mutating another plugin's private state:
-
-```js
-await window.feedBack.capabilities.dispatch({
-  capability: 'audio-effects',
-  command: 'select-chain',
-  source: 'rig_builder',
-  payload: { routeKey: 'desktop-main', providerId: 'rig-builder', authorization: 'user-action' }
-});
-
-const resolved = await window.feedBack.capabilities.dispatch({
-  capability: 'audio-effects',
-  command: 'resolve-plan',
-  source: 'nam_tone',
-  payload: { routeKey: 'desktop-main', target: { settingsKey: 'settings-v1-...' } }
-});
-```
-
-Providers should store public song/tone routing through the host-owned mapping index and keep their own preset or chain rows private. The mapping's `provider_ref` is opaque to core: NAM Tone can use a preset id, Rig Builder can use a chain/preset id, and each provider resolves that reference in `chain.resolve`.
-
-```js
-await window.feedBack.audioEffects.upsertMapping({
-  song_key: playbackTarget.settingsKey,
-  filename: playbackTarget.filename, // optional migration/debug context
-  tone_key: 'Dist',
-  provider_id: 'rig-builder',
-  provider_ref: 'chain:99',
-  label: 'Full Rig Builder chain',
-  source: 'manual',
-  active: true
-});
-
-const mappings = await window.feedBack.audioEffects.listMappings({
-  song_key: playbackTarget.settingsKey,
-  tone_key: 'Dist'
-});
-```
-
-Only one mapping is active for a `song_key + tone_key` at a time, but multiple providers may have rows for the same song/tone. The active row decides which provider core asks first; provider fallback remains explicit through provider priority and `fallbackProviderId` during `loadPlan(...)`.
-
-Browser or native executors should declare both provider scope and plan scope. A NAM-only browser executor should not claim Rig Builder plans just because it can load NAM files:
-
-```js
-window.feedBack.audioEffects.registerExecutor({
-  executorId: 'nam-tone-browser-wasm',
-  pluginId: 'nam_tone',
-  routeKey: 'desktop-main',
-  providerIds: ['nam-tone'],
-  supportedKinds: ['nam', 'ir'],
-  maxStages: 2,
-  sourceMode: 'browser',
-  loadChainPlan: request => loadNamToneWasmPlan(request)
-});
-```
-
-Trusted Desktop can advertise broader support, while provider-specific browser executors should keep their `providerIds`, `supportedKinds`, and `maxStages` as narrow as the runtime actually supports.
-
-The desktop executor is the trust boundary for physical loading. It should treat `assetRef` and `stateRef` values as opaque provider references, validate them through provider-owned lookup code, enforce local policy, then load or reject processor stages. Browser diagnostics should report route/provider/outcome summaries only.
-
 ## Audio Input And Monitoring Requester
 
-Plugins that need live instrument input should declare requester/observer intent and let the host expose redaction-safe source identity. Diagnostics must not contain raw device labels, stable hardware ids, or audio buffers.
+Plugins that need live instrument input declare requester/observer intent and let the host expose redaction-safe source identity. Diagnostics must not contain raw device labels, stable hardware ids, or audio buffers.
 
 ```json
 {
@@ -274,7 +162,7 @@ Plugins that need live instrument input should declare requester/observer intent
       "requests": ["inspect", "list-sources", "select-source", "open-source", "close-source"],
       "observes": ["source-registered", "source-selected", "source-opened", "source-open-degraded", "source-closed", "permission-denied"],
       "mode": "active",
-      "compatibility": "shim-allowed",
+      "compatibility": "none",
       "ownership": "requester-only",
       "safety": "sensitive",
       "version": 1
@@ -284,7 +172,7 @@ Plugins that need live instrument input should declare requester/observer intent
       "requests": ["inspect", "list-providers", "select-provider", "start", "stop", "set-direct-monitor"],
       "observes": ["provider-registered", "provider-selected", "provider-selection-required", "monitoring-started", "monitoring-degraded", "monitoring-unavailable", "monitoring-failed", "monitoring-denied", "monitoring-stopped", "direct-monitor-changed"],
       "mode": "active",
-      "compatibility": "shim-allowed",
+      "compatibility": "none",
       "ownership": "requester-only",
       "safety": "sensitive",
       "version": 1
@@ -296,7 +184,7 @@ Plugins that need live instrument input should declare requester/observer intent
 Requesters should list or inspect sources before opening them. `inspect`, `list-sources`, and `select-source` are prompt-free and must not call provider enumeration or open live input. When a requester needs audio, it dispatches `open-source` with a purpose and required channel shape. The requester identity is taken from the dispatch `source` (the authenticated caller) — a payload-supplied `requesterId` is ignored, so a requester cannot spoof another's identity or release a shared session it does not own. Compatible requesters share one open session; each requester later dispatches `close-source`, and the provider is closed only after the last requester releases it.
 
 ```js
-const api = window.feedBack.capabilities;
+const api = window.slopsmith.capabilities;
 await api.dispatch({ capability: 'audio-input', command: 'select-source', source: 'user', payload: { logicalSourceKey: 'browser:instrument:primary' } });
 const opened = await api.dispatch({
   capability: 'audio-input',
@@ -400,7 +288,7 @@ The Stems plugin remains the provider/owner of actual stem playback state. `core
       "operations": ["stem.get-state", "stem.apply-automation", "stem.restore-automation"],
       "events": ["owner-available", "automation-applied", "automation-restored", "automation-overridden", "claim-orphaned"],
       "mode": "active",
-      "compatibility": "shim-allowed",
+      "compatibility": "none",
       "ownership": "exclusive-owner",
       "safety": "safe",
       "version": 1
@@ -411,7 +299,7 @@ The Stems plugin remains the provider/owner of actual stem playback state. `core
 
 ## Playback Requester And Observer
 
-Plugins that need to inspect or coordinate song transport should declare `playback` requester/observer intent and use the capability dispatch surface instead of wrapping `window.playSong` or scraping the `<audio>` element. Raw media handles stay private to core; diagnostics expose only pseudonymous targets, sanitized timing, route, loop, requester, observer, and recent outcome summaries.
+Plugins that need to inspect or coordinate song transport declare `playback` requester/observer intent and use the capability dispatch surface. Raw media handles stay private to core; diagnostics expose only pseudonymous targets, sanitized timing, route, loop, requester, observer, and recent outcome summaries.
 
 ```json
 {
@@ -424,7 +312,7 @@ Plugins that need to inspect or coordinate song transport should declare `playba
       "requests": ["inspect", "pause", "resume", "seek", "set-loop", "clear-loop"],
       "observes": ["ready", "started", "paused", "resumed", "seeking", "seeked", "stopped", "loop-set", "loop-cleared"],
       "mode": "active",
-      "compatibility": "shim-allowed",
+      "compatibility": "none",
       "ownership": "requester-only",
       "safety": "safe",
       "version": 1
@@ -436,7 +324,7 @@ Plugins that need to inspect or coordinate song transport should declare `playba
 Fresh audible starts require a user action. Background plugins should call `inspect` first and attach to an existing compatible session; if a plugin needs to offer a play/start action, wire it to a visible user gesture and pass `authorization: "user-action"`.
 
 ```js
-const api = window.feedBack.capabilities;
+const api = window.slopsmith.capabilities;
 
 const state = await api.dispatch({
   capability: 'playback',
@@ -455,106 +343,10 @@ if (state.status !== 'idle') {
 }
 ```
 
-During migration, legacy uses of `window.playSong`, `song:*` events, `window.feedBack.seek`, and loop helpers remain available and are recorded as playback bridge hits. Treat bridge hits as migration telemetry: native capability requests should eventually cover normal plugin workflows so unexpected legacy hits disappear from diagnostics.
-
-## Progression Requester And Observer
-
-Plugins that report gameplay outcomes or react to player progression (spec 010) should declare `progression` requester/observer intent and use capability dispatch instead of private fetches. Externally postable event types are whitelisted (`minigame_run` in v1); `song_completed` is server-derived inside `/api/stats` and is denied at this surface. Backend plugin code can use the plugin-context hook `record_progression_event` instead (the minigames hub does).
-
-```json
-{
-  "id": "my_minigame",
-  "name": "My Minigame",
-  "standards": ["capability-pipelines.v1"],
-  "capabilities": {
-    "progression": {
-      "roles": ["requester", "observer"],
-      "requests": ["inspect", "record-event"],
-      "observes": ["challenge-completed", "quest-completed", "path-level-up", "rank-changed", "db-changed"],
-      "mode": "active",
-      "compatibility": "none",
-      "ownership": "requester-only",
-      "safety": "safe",
-      "version": 1
-    }
-  }
-}
-```
-
-`buy-item` and `equip-item` require a visible user gesture (`authorization: "user-action"`). Decibels are play-earned only; plugins must not present any purchase path.
-
-```js
-const api = window.feedBack.capabilities;
-
-const result = await api.dispatch({
-  capability: 'progression',
-  command: 'record-event',
-  source: 'my_minigame',
-  payload: { type: 'minigame_run', payload: { game_id: 'my-minigame', score: 420 } },
-});
-// result.payload lists challenges/quests completed by this event (toast UX).
-
-window.feedBack.on('progression:quest-completed', (e) => {
-  console.log('quest done:', e.detail.title, '+' + e.detail.reward_db + ' dB');
-});
-```
-
 ## Future Expansion Domains
 
-Some domain names are reserved for expected future contracts, but they are not registered in the runtime graph yet. For example, `ui.player-panels` is documented as a likely panel-host surface, but FeedBack does not currently expose a capability command for panel contributions. See [capability-roadmap.md](capability-roadmap.md) for the PR1 domain set and deferred-domain checklist.
+Some domain names are reserved for expected future contracts, but they are not registered in the runtime graph yet. For example, `ui.player-panels` is documented as a likely panel-host surface, but Slopsmith does not currently expose a capability command for panel contributions. See [capability-roadmap.md](capability-roadmap.md) for the PR1 domain set and deferred-domain checklist.
 
-Plugins should not declare future expansion domains until the corresponding host workflow ships. For current integrations, prefer active domains such as `library`, `playback`, `audio-mix`, `audio-input`, `audio-monitoring`, or `stems` intent matching the recipes above.
+Do not declare future expansion domains until the corresponding host workflow ships. For current integrations, use active domains such as `library`, `playback`, `audio-mix`, `audio-input`, `audio-monitoring`, or `stems` intent matching the recipes above.
 
-Invalid capability metadata is excluded from the capability graph, but legacy manifest fields still load through their existing app paths. The `library` workflow is native in PR1 and does not use compatibility shim metadata. Unsupported `capability-pipelines` versions are reported as incompatible and their runtime handlers must not execute.
-
-## Library Card Action (`ui.library-card-injection`)
-
-Delivered in fee[dB]ack v0.3.0 (frontend host). Plugins add per-song actions to
-the library cards by REGISTERING them instead of DOM-injecting onto
-`.song-card`. The library renders applicable actions in each card's action
-menu, dispatches the handler on click, and emits `action-result` events;
-the owner is visible in the Capability Inspector.
-
-```json
-{
-  "id": "my_card_action",
-  "name": "My Card Action",
-  "standards": ["capability-pipelines.v1"],
-  "capabilities": {
-    "ui.library-card-injection": {
-      "roles": ["provider"],
-      "operations": ["action.run"],
-      "events": ["action-registered", "action-result"],
-      "mode": "active",
-      "compatibility": "none",
-      "safety": "safe",
-      "version": 1
-    }
-  }
-}
-```
-
-Register the action from the plugin's `screen.js`:
-
-```js
-window.feedBack.libraryCardActions.register({
-  id: 'my_card_action.run',
-  pluginId: 'my_card_action',
-  label: 'Do the thing',
-  placement: 'menu',                 // 'menu' | 'inline' | 'overlay'
-  order: 50,
-  applies: (song) => song.format === 'sloppak',  // shown only when relevant
-  enabled: (song) => true,
-  run: async (song, ctx) => {        // ctx.source identifies the surface
-    await fetch('/api/plugins/my_card_action/run', {
-      method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ filename: song.filename }),
-    });
-  },
-});
-```
-
-`register(spec)` returns an `unregister()` fn. The host owns rendering,
-applicability, enabled state, and `action-result` events — plugins do not touch
-library DOM. Legacy `.song-card` DOM injection still works in the 0.2.x UI;
-migrate to this for the v0.3.0 native library.
+Invalid capability metadata is excluded from the capability graph. The `library` workflow is native in PR1 and does not use compatibility shim metadata. Unsupported `capability-pipelines` versions are reported as incompatible and their runtime handlers must not execute.

docs/capability-roadmap.md

@@ -38,7 +38,7 @@ The audio graph/session and effects slices promote these domains after PR1:
 
 `core.audio.session` is the runtime coordinator for all four domains. It owns `audio-mix`, `audio-input`, and `audio-monitoring`; for `stems`, it coordinates the active Stems provider without replacing the Stems plugin as the owner of actual stem playback/state.
 
-The focused audio-mix control-plane slice promotes fader discovery, read/write operations, committed-value events, native-over-legacy duplicate handling, route/analyser inspection, and compatibility removal gates into `audio-mix`. During migration, `window.feedBack.audio.registerFader(...)` remains available as a compatibility adapter, but the player mixer consumes the audio-mix control plane as its source of truth.
+The focused audio-mix control-plane slice promotes fader discovery, read/write operations, committed-value events, native-over-legacy duplicate handling, route/analyser inspection, and compatibility removal gates into `audio-mix`. During migration, `window.slopsmith.audio.registerFader(...)` remains available as a compatibility adapter, but the player mixer consumes the audio-mix control plane as its source of truth.
 
 The focused audio-input control-plane slice promotes source listing, prompt-free selection/inspection, explicit provider enumeration, open/close dispatch, channel-shape compatibility, selected-source persistence, shared requester sessions, and redaction-safe failure diagnostics into `audio-input`. During migration, legacy browser, desktop, or plugin-specific input handoffs should be recorded as `audio-input.legacy-source` bridge hits. Native providers own the visible source when they share a logical source key with a compatibility-backed source; the compatibility source remains diagnostics-only until normal playback shows no unexpected legacy hits.
 
@@ -50,7 +50,7 @@ The focused audio-effects control-plane slice promotes provider registration, us
 
 The playback slice promotes `playback` from a deferred domain to an active exclusive-owner core domain. It owns transport commands (`start`, `pause`, `resume`, `stop`, `seek`, `set-loop`, `clear-loop`, `inspect`), lifecycle events (`playback:requested`, `playback:loading`, `playback:ready`, `playback:started`, `playback:paused`, `playback:resumed`, `playback:seeking`, `playback:seeked`, `playback:ended`, `playback:stopped`, route events, bridge hits, and loop events), and redaction-safe diagnostics for session, target, timing, route, loop, requester, observer, bridge, and recent outcome state.
 
-The implementation deliberately keeps raw transport handles in `static/app.js`: the domain host registers a private adapter and receives sanitized snapshots instead of exposing the `<audio>` element, JUCE player, decoded audio buffers, waveform data, or native route handles. Playback targets expose a pseudonymous arrangement-scoped `targetId` plus a hashed per-song `settingsKey` so observers can store local per-song settings without reading raw filenames or paths. Compatibility bridges currently account for `window.playSong`, `window.feedBack` transport helpers, legacy song events, loop helpers, media snapshots, route switching, and native-route handoff. Fresh audible starts require `authorization: "user-action"`; background requesters can inspect or control only an existing compatible session according to the command conflict policy.
+The implementation deliberately keeps raw transport handles in `static/app.js`: the domain host registers a private adapter and receives sanitized snapshots instead of exposing the `<audio>` element, JUCE player, decoded audio buffers, waveform data, or native route handles. Playback targets expose a pseudonymous arrangement-scoped `targetId` plus a hashed per-song `settingsKey` so observers can store local per-song settings without reading raw filenames or paths. Compatibility bridges currently account for `window.playSong`, `window.slopsmith` transport helpers, legacy song events, loop helpers, media snapshots, route switching, and native-route handoff. Fresh audible starts require `authorization: "user-action"`; background requesters can inspect or control only an existing compatible session according to the command conflict policy.
 
 Playback bridge removal gates are: bundled and first-party plugins use native playback dispatch for normal requester/observer workflows; normal play/pause/seek/loop/route smoke runs show no unexpected bridge hits beyond compatibility-only listeners; playback diagnostics distinguish denied, no-target, stale, cancelled, degraded, unavailable, failed, and stopped outcomes; repeated plugin hydration does not duplicate requesters, observers, wrappers, or bridge entries; and exported support snapshots contain no raw song filenames, paths, URLs, media handles, buffers, waveforms, samples, or recordings.
 
@@ -82,7 +82,7 @@ This is the recommended order for UI/UX capability work only. It excludes audio
 | 5 | Player controls | `ui.player-controls` | Direct player control DOM edits, control popovers, button/slider globals | Ordered player-control regions with stable command buttons, popovers, sliders, disabled states, and contribution teardown | Player controls can be added/removed/reordered without plugins mutating the control bar directly. |
 | 6 | Player overlays | `ui.player-overlays`, `tours` | Overlay canvases, tour overlays, highway visibility listeners, direct z-index management | Overlay host with anchors, z-order, hit-testing, renderer compatibility flags, visibility events, and cleanup | Fretboard, section map, tours, transpose, step mode, and similar overlays can coexist without private layering rules. |
 | 7 | Player panels | `ui.player-panels` | Splitscreen panel DOM, panel-local highway instances, panel-local shortcuts | Panel host with layout slots, active-panel focus, per-panel renderer selection, per-panel shortcuts, visibility, and teardown | Splitscreen-style panels can be composed through host APIs instead of wrapping playback/screen globals. |
-| 8 | Visualization UX | `visualization` | `type: "visualization"`, `window.feedBackViz_*`, viz picker state, auto-match hooks | Renderer provider registry with picker integration, auto-match ordering, context-type metadata, fallback/revert events, and per-panel selection | Renderer selection and failure recovery are fully attributed in diagnostics; picker options no longer depend on global scans. |
+| 8 | Visualization UX | `visualization` | `type: "visualization"`, `window.slopsmithViz_*`, viz picker state, auto-match hooks | Renderer provider registry with picker integration, auto-match ordering, context-type metadata, fallback/revert events, and per-panel selection | Renderer selection and failure recovery are fully attributed in diagnostics; picker options no longer depend on global scans. |
 | 9 | Library and guided UX extensions | `ui.library-card-injection`, `tours` | Library card buttons, tour registration globals, target selectors | Contribution APIs for library card actions and guided-tour steps with applicability, target resolution, and action-result events | Library actions and tours can be inspected, disabled, and tested independently of plugin-private DOM injection. |
 | 10 | Theme and polish surfaces | `settings` or candidate `ui.theme` | Global theme settings, direct stylesheet/class mutation | Theme contribution metadata for tokens, selected theme, preview/apply/restore lifecycle, and diagnostics without user secrets | Themes are reversible and attributable, and visual changes do not depend on hidden global state. |
 
@@ -108,7 +108,7 @@ These domains are planned but should stay out of the runtime graph until a host
 | `ui.player-overlays` | exclusive-owner | safe | Overlay contributions layered over player or highway surfaces. | Overlay placement and z-order rules that coexist with legacy overlays. |
 | `plugins` | exclusive-owner | privileged | Plugin enable/disable/install/update workflows. | Visible user confirmation, rollback, and disabled-handler enforcement. |
 | `jobs` | multi-provider | privileged | Long-running jobs, cancellation, status, failures. | Scheduling limits, cancellation semantics, and user-visible failures. |
-| `midi-control` | multi-provider | sensitive | MIDI control mappings only (CC/pitchbend/note → action routing), consuming `midi-input` for device access. Device discovery/selection/open is split out to the delivered `midi-input` domain (spec 012). | A concrete mapping/routing workflow on top of the `midi-input` device plane (#882). |
+| `midi-control` | multi-provider | sensitive | MIDI device providers and control mappings. | Device consent and redacted diagnostics. |
 | `audio-input` | multi-provider | sensitive | Audio input device providers, source selection, open/close lifecycle, shared sessions, and redacted failure diagnostics. | Promoted by the audio graph/session slice and implemented by the audio-input control-plane slice. |
 | `tempo-clock` | multi-provider | safe | Tempo/clock provider registration and consumers. | A concrete tempo source and consumer workflow. |
 
@@ -127,7 +127,7 @@ These candidate domains were surfaced by the included plugin inventory but are n
 | `recording` | multi-provider | sensitive | Arm/start/stop capture, take upload/import, capture-source binding, latency metadata, and storage cleanup. | Studio and karaoke workflows need capture/session semantics distinct from raw audio input. |
 | `practice-session` | multi-provider | safe | Practice session lifecycle, goals, score/progress events, chart segment focus, and journal persistence boundaries. | Practice Journal, Minigames, Guitar Theory, Flappy Bend, and Note Detect imply practice/progression state. |
 | `collaboration` | multi-provider | sensitive | Room/session lifecycle, participant identity redaction, shared playback sync, conflict policy, and disconnect recovery. | Multiplayer is a distinct real-time coordination surface. |
-| `external-services` | diagnostic or privileged metadata | privileged | Network/download/subprocess integration inventory, endpoint attribution, confirmation policy, and failure diagnostics. | Update Manager, Find More, Sloppak Converter, and media jobs reach outside local FeedBack state. |
+| `external-services` | diagnostic or privileged metadata | privileged | Network/download/subprocess integration inventory, endpoint attribution, confirmation policy, and failure diagnostics. | Update Manager, Find More, Sloppak Converter, and media jobs reach outside local Slopsmith state. |
 
 Candidate domains can also remain as safety metadata on existing domains. For example, `external-services` may be more useful as a cross-cutting review tag than as a dispatchable runtime capability.
 
@@ -141,7 +141,7 @@ PR1 does not add per-domain versioning. The `capability-pipelines.v1` standard v
 - Changing command payloads, return payloads, or dispatch outcomes incompatibly is breaking.
 - A breaking change requires either a future `capability-pipelines` version or a clearly new domain name if parallel support is needed.
 
-Per-domain versions should wait until FeedBack has a concrete need for multiple incompatible versions of the same domain to coexist.
+Per-domain versions should wait until Slopsmith has a concrete need for multiple incompatible versions of the same domain to coexist.
 
 ## Future Domain PR Checklist
 

docs/capability-safety-matrix.md

@@ -2,7 +2,7 @@
 
 Capability declarations include a safety class so reviewers can decide whether a domain can ship as a normal plugin contract or needs extra enforcement first.
 
-Core domains also have a review scope. **Active contract** domains are wired to current FeedBack behavior and should be tested as working integration points. Expected future domains are documented below, but are intentionally not registered in the runtime graph until FeedBack ships the corresponding host UI or provider workflow.
+Core domains also have a review scope. **Active contract** domains are wired to current Slopsmith behavior and should be tested as working integration points. Expected future domains are documented below, but are intentionally not registered in the runtime graph until Slopsmith ships the corresponding host UI or provider workflow.
 
 | Domain | Owner Kind | Safety Class | Stable Commands | Provider Operations | Notes |
 |--------|------------|--------------|-----------------|---------------------|-------|
@@ -14,15 +14,13 @@ Core domains also have a review scope. **Active contract** domains are wired to
 | audio-monitoring | provider-coordinator | sensitive | inspect, list-providers, register-provider, unregister-provider, select-provider, start, stop, set-direct-monitor | monitoring.start, monitoring.stop, monitoring.status, monitoring.set-direct-monitor | Inspect/list/select/status are prompt-free. Fresh monitoring start requires explicit user action; background requesters may only attach to an active compatible session. Outcomes distinguish handled, stopped, denied, unavailable, degraded, failed, no-owner, no-handler, unsupported-command, incompatible, incompatible-version, provider-selection-required, and user-action-required. Diagnostics redact raw device labels, hardware ids, paths, secrets, live handles, buffers, samples, waveforms, and recordings. |
 | stems | coordinator plus plugin provider | safe | inspect, mute, restore | stem.get-state, stem.apply-automation, stem.restore-automation | Core coordinates claims/overrides; the active Stems provider owns actual stem state/playback. |
 | playback | exclusive-owner | safe | inspect, start, pause, resume, stop, seek, set-loop, clear-loop, register-requester, register-observer | none | Core owns the transport control plane while `app.js` keeps raw media handles private. Fresh audible starts require explicit user action. Diagnostics expose pseudonymous targets, sanitized route/timing/loop state, requester/observer summaries, bridge hits, bounded recent outcomes, and no audio elements, native handles, decoded buffers, samples, waveforms, or recordings. |
-| progression | exclusive-owner | safe | inspect, record-event, list-shop, buy-item, equip-item | none | Core owns mastery rank, the challenge/quest engine, the Decibels wallet, and the cosmetics shop (spec 010). `record-event` accepts whitelisted types only (`minigame_run`); `song_completed` is server-derived in `/api/stats` and denied here. `buy-item`/`equip-item` require explicit user action. Decibels are play-earned only — no real-money path exists or may be added. Diagnostics (`feedBack.progression.diag.v1`) carry content warnings, rank/level/quest counts, and wallet totals; no song filenames or display names. |
+| progression | exclusive-owner | safe | inspect, record-event, list-shop, buy-item, equip-item | none | Core owns mastery rank, the challenge/quest engine, the Decibels wallet, and the cosmetics shop (spec 010). `record-event` accepts whitelisted types only (`minigame_run`); `song_completed` is server-derived in `/api/stats` and denied here. `buy-item`/`equip-item` require explicit user action. Decibels are play-earned only — no real-money path exists or may be added. Diagnostics (`slopsmith.progression.diag.v1`) carry content warnings, rank/level/quest counts, and wallet totals; no song filenames or display names. |
 | audio-effects | provider-coordinator | sensitive | inspect, list-providers, register-provider, unregister-provider, select-chain, resolve-plan, inspect-route, bypass, restore, fallback, activate-segment, set-stage-bypass, set-stage-parameter, record-bridge-hit | chain.resolve, chain.inspect, segment.activate, stage.set-bypass, stage.set-parameter, route.bypass, route.restore | Core owns provider selection, route state, chain-plan schema validation, fallback accounting, and diagnostics. Providers propose opaque NAM/IR/VST/utility chain plans; trusted desktop/native code validates and loads processors. Chain selection and route bypass/restore require explicit user action or restored selection. Diagnostics omit raw paths, filenames, URLs, model/IR names, native preset JSON, VST state blobs, handles, callbacks, DOM nodes, audio buffers, samples, and waveforms. |
 
-| visualization | provider-coordinator | safe | inspect, list-providers, select-renderer, clear-renderer | renderer.create, renderer.destroy | Highway renderer provider registry, picker-delegated selection, auto-match attribution, and failure fallback. `renderer.create` maps to the legacy `window.feedBackViz_*` factory `init(canvas, ctx)` call; `renderer.destroy` maps to the factory `destroy()` teardown. Legacy `type: "visualization"` manifests and `window.feedBackViz_*` globals are accounted compatibility shims. Diagnostics carry provider ids/labels, selection source, last auto-match outcome, and last failure — no song filenames, titles, or arrangement names. |
+| visualization | provider-coordinator | safe | inspect, list-providers, select-renderer, clear-renderer | renderer.create, renderer.destroy | Highway renderer provider registry, picker-delegated selection, auto-match attribution, and failure fallback. `renderer.create` maps to the legacy `window.slopsmithViz_*` factory `init(canvas, ctx)` call; `renderer.destroy` maps to the factory `destroy()` teardown. Legacy `type: "visualization"` manifests and `window.slopsmithViz_*` globals are accounted compatibility shims. Diagnostics carry provider ids/labels, selection source, last auto-match outcome, and last failure — no song filenames, titles, or arrangement names. |
 
 | note-detection | provider-coordinator | sensitive | inspect, register-provider, unregister-provider, open-binding, close-binding, set-target, clear-target | pitch.estimate, verify.target | Detection-binding control plane (spec 009): providers (midi/engine/js) serve primitives; each requester binds its own redacted tuning context; consumers own judgment, hit/miss flow as observability events. Legacy `highway.setNoteStateProvider` is an accounted shim. Diagnostics carry provider/binding summaries and bounded outcomes — no raw audio, sample data, device labels, or song identity. |
 
-| midi-input | provider-coordinator | sensitive | inspect, list-sources, discover, select-source, open-source, close-source | source.enumerate, source.describe, source.open, source.close | Core-owned MIDI device control plane (spec 012), the MIDI analog of `audio-input`. Inspect/list/select are prompt-free; `discover` is the Web-MIDI permission boundary (`requestMIDIAccess()` gates the whole input list) and records denied/unavailable outcomes; `open-source` attaches a shared listener session and never re-prompts. Selection persists by redaction-safe `logicalSourceKey`. Diagnostics redact device labels and never include raw MIDI messages or live handles. |
-
 Privileged commands are roadmap-only until they have: a visible user confirmation path, diagnostics redaction rules, failure recovery, and tests that prove disabled or incompatible participants cannot execute handlers.
 
 ## Expected Future Domains
@@ -40,9 +38,9 @@ These domains are expected future capability contracts, not current runtime grap
 | ui.player-overlays | exclusive-owner | safe | register-contribution, mount, unmount, set-visible, reorder-by-policy, inspect | Needs overlay placement rules that coexist with legacy highway overlays. |
 | plugins | exclusive-owner | privileged | enable, disable, install-missing, update, inspect | Needs explicit user confirmation for writes/install/update. |
 | jobs | multi-provider | privileged | register, inspect, cancel | Needs scheduling limits, cancellation semantics, and user-visible failures. |
-| midi-control | multi-provider | sensitive | list-mappings, get-mapping, set-mapping, delete-mapping, activate-mapping, inspect | Mappings ONLY — CC/pitchbend/note → semantic action routing (spec 013). Device discovery/selection/open is NOT this domain's job: it consumes the delivered `midi-input` domain for device access. Needs a concrete mapping consumer (the MIDI control plugin / drums learn-mode) + redacted diagnostics (no raw MIDI streams) before promotion. |
+| midi-control | multi-provider | sensitive | register, inspect | Needs device consent and redacted diagnostics. |
 | tempo-clock | multi-provider | safe | register, inspect | Needs a concrete provider and consumer workflow. |
 
-Planned domains should also stay out of the runtime graph until FeedBack ships the corresponding user-facing workflows.
+Planned domains should also stay out of the runtime graph until Slopsmith ships the corresponding user-facing workflows.
 
 When promoting a planned domain, use [capability-review-preflight.md](capability-review-preflight.md) before opening the PR. The preflight captures recurring review requirements for identity, redaction, outcome propagation, diagnostics freshness, schema consistency, and teardown.

docs/diagnostics-bundle-spec.md

@@ -1,7 +1,7 @@
-# FeedBack Diagnostics Bundle — Format Specification
+# Slopsmith Diagnostics Bundle — Format Specification
 
-This document is the authoritative reference for the `feedBack-diag-*.zip`
-file produced by Settings → Export Diagnostics (feedBack#166).
+This document is the authoritative reference for the `slopsmith-diag-*.zip`
+file produced by Settings → Export Diagnostics (slopsmith#166).
 
 The bundle is consumed by humans (maintainers reading bug reports) **and**
 AI agents (auto-triage, code-aware assistants). Every JSON file inside
@@ -15,17 +15,17 @@ version without guessing.
 A diagnostic bundle is a plain ZIP archive. The default filename is:
 
 ```
-feedBack-diag-<feedBack-version>-<YYYYMMDD-HHMMSS>.zip
+slopsmith-diag-<slopsmith-version>-<YYYYMMDD-HHMMSS>.zip
 ```
 
 Top-level layout:
 
 ```
-feedBack-diag-0.2.4-20260503-143022.zip
+slopsmith-diag-0.2.4-20260503-143022.zip
 ├── manifest.json          AI-friendly index, schema 1
 ├── README.txt             Human-friendly: what's in here, how to read
 ├── system/
-│   ├── version.json       feedBack + python + OS
+│   ├── version.json       slopsmith + python + OS
 │   ├── env.json           allowlisted env vars only (no secrets)
 │   ├── hardware.json      backend hardware (container-limited if Docker)
 │   └── plugins.json       loaded + orphan plugins, with git info
@@ -53,7 +53,7 @@ logs, console, plugins). Missing sections are not represented in
 {
   "schema": 1,                          // bundle schema; bump = breaking change
   "exported_at": "2026-05-03T14:30:22Z",
-  "feedBack_version": "0.2.4",
+  "slopsmith_version": "0.2.4",
   "runtime": "docker",                  // "docker" | "electron" | "bare"
   "redacted": true,                     // were redactions applied?
   "files": [
@@ -94,7 +94,7 @@ Field semantics:
 ```jsonc
 {
   "schema": "system.version.v1",
-  "feedBack_version": "0.2.4",
+  "slopsmith_version": "0.2.4",
   "python":   { "version": "3.12.4", "implementation": "CPython", "executable": "/usr/bin/python" },
   "os":       { "system": "Linux", "release": "6.5.0", "machine": "x86_64" },
   "exported_at": "2026-05-03T14:30:22Z"
@@ -109,13 +109,13 @@ Field semantics:
   "vars": {
     "LOG_LEVEL": "INFO",
     "LOG_FORMAT": "json",
-    "FEEDBACK_RUNTIME": "electron"
+    "SLOPSMITH_RUNTIME": "electron"
   }
 }
 ```
 
 Allowlisted env var keys only (see `ENV_ALLOWLIST` in `lib/diagnostics_bundle.py`):
-`LOG_LEVEL`, `LOG_FORMAT`, `LOG_FILE`, `FEEDBACK_RUNTIME`, `PORT`, `HOST`,
+`LOG_LEVEL`, `LOG_FORMAT`, `LOG_FILE`, `SLOPSMITH_RUNTIME`, `PORT`, `HOST`,
 `TZ`, `PYTHONUNBUFFERED`, `DEMUCS_SERVER_URL`. New entries require an
 allowlist edit; secrets must never be added.
 
@@ -187,7 +187,7 @@ entry explaining why.
       "version": "0.1.0",
       "loaded": false,
       "dir": "broken",
-      "path": "/home/user/.config/feedBack/plugins/broken"
+      "path": "/home/user/.config/slopsmith/plugins/broken"
     }
   ]
 }
@@ -223,7 +223,7 @@ appear in `capability_unsupported_versions` and should be treated as
 non-executable runtime intent.
 
 Client-side capability snapshots contributed under `plugins/capabilities/client.json`
-use schema `feedBack.capabilities.diagnostics.v1`. They include current
+use schema `slopsmith.capabilities.diagnostics.v1`. They include current
 pipelines, participants, conflicts, missing providers, user overrides, active
 or orphaned claims, claim lifecycle records, compatibility shim hit counts,
 unsupported-version reports, and recent decisions. The runtime caps this
@@ -235,7 +235,7 @@ current graph state.
 ```jsonc
 {
   "schema": "logs.server.v1",
-  "log_file": "/data/log/feedBack.log",
+  "log_file": "/data/log/slopsmith.log",
   "exists": true,
   "size_bytes": 8388608,
   "tail_bytes": 5242880,
@@ -341,7 +341,7 @@ serialized as `"[circular]"`.
 `runtime.kind` rules:
 
 - `"electron"` if `navigator.userAgent` contains `Electron/`. Versions
-  populated when the desktop launcher exposes `window.feedBackElectron`
+  populated when the desktop launcher exposes `window.slopsmithElectron`
   via a preload `contextBridge`.
 - `"browser"` otherwise.
 
@@ -367,7 +367,7 @@ typically prefix their keys with their `plugin_id`.
 {
   "schema": "client.ua.v1",
   "userAgent": "...",
-  "url": "https://feedBack.local/",
+  "url": "https://slopsmith.local/",
   "screen": { ... }
 }
 ```
@@ -406,10 +406,10 @@ dispatch by plugin schema.
 
 Detection precedence (backend):
 
-1. `FEEDBACK_RUNTIME` env var (`"electron"`/`"docker"`/`"bare"`)
+1. `SLOPSMITH_RUNTIME` env var (`"electron"`/`"docker"`/`"bare"`)
 2. `/.dockerenv` exists OR `/proc/1/cgroup` mentions `docker`/
    `containerd`/`kubepods` → `docker`
-3. Parent process name matches `electron` or `FeedBack` → `electron`
+3. Parent process name matches `electron` or `Slopsmith` → `electron`
 4. Default: `bare`
 
 Detection (frontend): `Electron/` in user agent → `electron`, else
@@ -430,7 +430,7 @@ between bundles):
 |--------------------|-----------------------------------------------------|
 | `<DLC_DIR>`        | configured DLC root path                             |
 | `<HOME>`           | user's home directory                                |
-| `<CONFIG_DIR>`     | feedBack config directory                           |
+| `<CONFIG_DIR>`     | slopsmith config directory                           |
 | `<song:HASH8>`     | song filename / basename (8-char salted SHA-256)    |
 | `<ip:HASH6>`       | IPv4 / IPv6 address                                  |
 | `<redacted>`       | bearer token, `key=`/`token=`/`api_key=` query strings |
@@ -508,7 +508,7 @@ machine.
 ```
 
 Frontend plugins push diagnostics by calling
-`window.feedBack.diagnostics.contribute(plugin_id, payload)` before the
+`window.slopsmith.diagnostics.contribute(plugin_id, payload)` before the
 user clicks Export. The payload is written to `plugins/<id>/client.json`
 (gated on the same "Plugin diagnostics" toggle as backend plugin files).
 

docs/diagnostics/README.md

@@ -1,4 +1,4 @@
-# FeedBack diagnostic sloppaks
+# Slopsmith diagnostic sloppaks
 
 Generated, non-copyrighted mini-songs for technique-assessment style
 checks. Report-only — they do not change gameplay settings or detection
@@ -6,7 +6,7 @@ thresholds.
 
 ## Basic Guitar (POC)
 
-**Artifact:** `feedBack-diagnostic-basic-guitar.sloppak`
+**Artifact:** `slopsmith-diagnostic-basic-guitar.sloppak`
 
 **Contents (~55 s):**
 
@@ -23,7 +23,7 @@ for future Technique Assessment integration).
 
 ## Rebuild
 
-From the feedBack repo root (requires `ffmpeg`; the feedBack Docker image
+From the slopsmith repo root (requires `ffmpeg`; the slopsmith Docker image
 has `libvorbis`, Homebrew ffmpeg may use the built-in `vorbis` encoder):
 
 ```bash
@@ -36,14 +36,14 @@ On library scan startup (and periodic rescans), the server copies bundled
 diagnostic sloppaks into the user DLC folder when missing or when the
 bundled source is newer:
 
-`DLC_DIR/diagnostics-builtin/feedBack-diagnostic-basic-guitar.sloppak`
+`DLC_DIR/diagnostics-builtin/slopsmith-diagnostic-basic-guitar.sloppak`
 
-Source: `docs/diagnostics/feedBack-diagnostic-basic-guitar.sloppak` (next to
+Source: `docs/diagnostics/slopsmith-diagnostic-basic-guitar.sloppak` (next to
 `server.py` in dev; must be included in the desktop bundle — see
-`feedBack-desktop/scripts/bundle-feedBack.sh`).
+`slopsmith-desktop/scripts/bundle-slopsmith.sh`).
 
 Unlike `tutorials-builtin/`, `diagnostics-builtin/` **is** included in the
-library scan. Tracks appear under **FeedBack** /
+library scan. Tracks appear under **Slopsmith** /
 **Technique Assessment Diagnostics**.
 
 Existing destination files are not overwritten unless the bundled source
@@ -55,10 +55,10 @@ are never touched.
 Normally seeding is automatic once a DLC folder is configured. To test a
 custom copy or an unreleased build:
 
-1. Copy `feedBack-diagnostic-basic-guitar.sloppak` into your FeedBack
+1. Copy `slopsmith-diagnostic-basic-guitar.sloppak` into your Slopsmith
    DLC folder (e.g. `diagnostics-test/` or any scanned path).
-2. Restart FeedBack or trigger a library rescan if the song does not appear.
-3. Load **FeedBack Diagnostic — Basic Guitar**.
+2. Restart Slopsmith or trigger a library rescan if the song does not appear.
+3. Load **Slopsmith Diagnostic — Basic Guitar**.
 4. Play the **Diagnostic Guitar** arrangement.
 5. Confirm the 3D highway shows open notes and power-chord gems.
 6. Turn **Detect** on — note_detect should push the chart to the desktop

docs/diagnostics/build_diagnostic_basic_guitar.py

@@ -1,16 +1,16 @@
-"""Build the FeedBack Diagnostic — Basic Guitar sloppak (POC).
+"""Build the Slopsmith Diagnostic — Basic Guitar sloppak (POC).
 
 A short, generated, non-copyrighted mini-song for technique-assessment
 style checks: open strings, one fretted note, and repeated E5 power chords.
 Click-track backing only — no external audio.
 
-Run from the feedBack repo root:
+Run from the slopsmith repo root:
 
     python3 docs/diagnostics/build_diagnostic_basic_guitar.py
 
 Output (zip archive):
 
-    docs/diagnostics/feedBack-diagnostic-basic-guitar.sloppak
+    docs/diagnostics/slopsmith-diagnostic-basic-guitar.sloppak
 
 Pattern matches docs/benchmarks/note_detect_v1/build_benchmark.py.
 """
@@ -289,8 +289,8 @@ def build_chart():
     }
 
     manifest = {
-        'title': 'FeedBack Diagnostic — Basic Guitar',
-        'artist': 'FeedBack',
+        'title': 'Slopsmith Diagnostic — Basic Guitar',
+        'artist': 'Slopsmith',
         'album': 'Technique Assessment Diagnostics',
         'year': 2026,
         'duration': round(end_t, 3),
@@ -405,7 +405,7 @@ def build(output_zip: Path) -> dict:
 
 
 def _diagnostic_readme(duration_s: float) -> str:
-    return f"""# FeedBack Diagnostic — Basic Guitar
+    return f"""# Slopsmith Diagnostic — Basic Guitar
 
 Short generated diagnostic track for technique-assessment style checks.
 Non-copyrighted click-track backing only.
@@ -422,7 +422,7 @@ Built by docs/diagnostics/build_diagnostic_basic_guitar.py
 
 def main():
     repo_root = Path(__file__).resolve().parents[2]
-    default_out = Path(__file__).resolve().parent / 'feedBack-diagnostic-basic-guitar.sloppak'
+    default_out = Path(__file__).resolve().parent / 'slopsmith-diagnostic-basic-guitar.sloppak'
     out = Path(sys.argv[1]) if len(sys.argv) > 1 else default_out
     if not out.is_absolute():
         out = repo_root / out

docs/note-detect-tuning.md

@@ -13,7 +13,7 @@ Detection quality varies by guitar pickup, audio interface, monitor latency, the
 
 ## The benchmark sloppak
 
-The distributable sloppak ships in-tree at [docs/benchmarks/note_detect_v1/note_detect_benchmark_v1.sloppak](benchmarks/note_detect_v1/note_detect_benchmark_v1.sloppak) — drop it directly in your library folder (e.g. `<your-library>/sloppak/`) and it shows up in the library. The file is a zip under the hood but feedBack's loader (`is_sloppak`) keys off the `.sloppak` suffix, so don't rename. After playing it once it ends up extracted under `static/sloppak_cache/note_detect_benchmark_v1.sloppak/`, which is where the harness reads its `arrangements/lead.json` from. 90 BPM, 8 numbered sections, ~2:20 total:
+The distributable sloppak ships in-tree at [docs/benchmarks/note_detect_v1/note_detect_benchmark_v1.sloppak](benchmarks/note_detect_v1/note_detect_benchmark_v1.sloppak) — drop it directly in your library folder (e.g. `<your-library>/sloppak/`) and it shows up in the library. The file is a zip under the hood but slopsmith's loader (`is_sloppak`) keys off the `.sloppak` suffix, so don't rename. After playing it once it ends up extracted under `static/sloppak_cache/note_detect_benchmark_v1.sloppak/`, which is where the harness reads its `arrangements/lead.json` from. 90 BPM, 8 numbered sections, ~2:20 total:
 
 | Section | Notes | Isolates |
 |---|---|---|
@@ -28,10 +28,10 @@ The distributable sloppak ships in-tree at [docs/benchmarks/note_detect_v1/note_
 
 Every chart note has `sus > 0` — so anything you tune against this benchmark exercises the sustain path, not staccato detection. (If we add a staccato section later, the cleanest split is by section name; don't categorize by `sus` value on the event log — see the "Common pitfalls" section.)
 
-To rebuild after edits to the exercise list, follow the docstring at the top of `build_benchmark.py`. The script writes both an unzipped directory (`.sloppak/`) and a zipped archive (`.sloppak.zip`). The feedBack library scanner (`lib/sloppak.py::is_sloppak()`) matches on the `.sloppak` suffix, **not** on `.sloppak.zip` — the directory form is usable as-is, but the zip output needs its suffix swapped before it'll be discovered. After regenerating, copy the zip output to the tracked path with the `.sloppak` suffix so it stays a drop-in install. Run from the feedBack repo root so the relative paths resolve:
+To rebuild after edits to the exercise list, follow the docstring at the top of `build_benchmark.py`. The script writes both an unzipped directory (`.sloppak/`) and a zipped archive (`.sloppak.zip`). The slopsmith library scanner (`lib/sloppak.py::is_sloppak()`) matches on the `.sloppak` suffix, **not** on `.sloppak.zip` — the directory form is usable as-is, but the zip output needs its suffix swapped before it'll be discovered. After regenerating, copy the zip output to the tracked path with the `.sloppak` suffix so it stays a drop-in install. Run from the slopsmith repo root so the relative paths resolve:
 
 ```bash
-# From the feedBack repo root.
+# From the slopsmith repo root.
 cp static/sloppak_cache/note_detect_benchmark_v1.sloppak.zip \
    docs/benchmarks/note_detect_v1/note_detect_benchmark_v1.sloppak
 ```
@@ -46,7 +46,7 @@ The typical cycle for one tuning hypothesis:
 2. **Arm a recording** from the gear popover next to the Detect button on the player. Arm before pressing Play.
 3. **Play through the benchmark** (or any song) at **1.0× playback speed**. Half-speed playback breaks audio↔chart alignment and produces all-miss garbage — see Pitfalls.
 4. **Auto-save fires on song end.** The WAV lands in `static/note_detect_recordings/note_detect_<slug>_<timestamp>.wav` (bind-mounted, so it's reachable from the host without a copy step).
-5. **Run the headless harness** with a known config. Paths below assume the note_detect plugin is cloned into `plugins/note_detect/` (see the feedBack README for the plugin-install flow — note_detect ships as a separate repo):
+5. **Run the headless harness** with a known config. Paths below assume the note_detect plugin is cloned into `plugins/note_detect/` (see the slopsmith README for the plugin-install flow — note_detect ships as a separate repo):
     ```bash
     node plugins/note_detect/tools/harness.js \
         --audio static/note_detect_recordings/note_detect_<…>.wav \
@@ -162,7 +162,7 @@ The same workflow works on any tuning change — A/V offset sweep, frame-size sw
 
 ### "Did my detector change improve things?" — ad hoc
 
-Same recording, same chart, two harness runs. Recipe assumes you're at the feedBack repo root *and* that the Note Detection plugin is cloned at `plugins/note_detect/` per the README. The detector source lives in that nested plugin repo, which feedBack's `.gitignore` excludes via `plugins/*/`, so the stash dance has to run **inside** the plugin repo — `git stash` from the feedBack root would either bail out or, worse, stash unrelated feedBack edits.
+Same recording, same chart, two harness runs. Recipe assumes you're at the slopsmith repo root *and* that the Note Detection plugin is cloned at `plugins/note_detect/` per the README. The detector source lives in that nested plugin repo, which slopsmith's `.gitignore` excludes via `plugins/*/`, so the stash dance has to run **inside** the plugin repo — `git stash` from the slopsmith root would either bail out or, worse, stash unrelated slopsmith edits.
 
 The stash dance below uses **`git stash push -u -m "..."`** to give the stash a known name *and* include untracked files. `-u` matters: if your detector change added a new module or fixture, an untracked-file-blind stash would leave it on disk during the "before" run and contaminate the baseline. The script then asserts a stash was actually created before popping (so a clean worktree doesn't silently pop someone else's WIP), wraps each step in **`set -euo pipefail`** so a failed `git stash pop` (e.g., conflict) aborts before the "after" harness records an invalid result, and uses `trap` to surface any failure with a clear message.
 
@@ -172,7 +172,7 @@ PLUGIN_DIR=plugins/note_detect
 HARNESS=$PLUGIN_DIR/tools/harness.js
 STASH_MSG="harness-before-$$"
 trap 'echo "harness recipe aborted — stash may still be in $PLUGIN_DIR (\"git -C $PLUGIN_DIR stash list\")" >&2' ERR
-# Stash the detector edits inside the plugin repo, not the feedBack root.
+# Stash the detector edits inside the plugin repo, not the slopsmith root.
 # -u also stashes untracked files (new modules, fixtures) so they don't
 # leak into the "before" baseline. `|| true` only swallows the
 # clean-worktree case, which the next line catches explicitly.
@@ -223,9 +223,9 @@ Find the note's `t` in the chart, then grep the event log for entries near that
 
 The Note Detection plugin lives in its own repository — these links go to the canonical source at github.com. If you've cloned the plugin into a local `plugins/note_detect/` next to this repo, the same files are at the equivalent path on disk.
 
-- Plugin source: [`screen.js`](https://github.com/got-feedback/feedBack-plugin-notedetect/blob/main/screen.js) — `matchNotes`, `checkMisses`, `_diagTimingErrors` / `_diagTimingErrorsHits`, `getDiagnostic`.
-- Routes: [`routes.py`](https://github.com/got-feedback/feedBack-plugin-notedetect/blob/main/routes.py) — the `/api/plugins/note_detect/recording` and `/api/plugins/note_detect/live-judgment` endpoints.
-- Harness: [`tools/harness.js`](https://github.com/got-feedback/feedBack-plugin-notedetect/blob/main/tools/harness.js).
-- Regression driver: [`tools/regression.js`](https://github.com/got-feedback/feedBack-plugin-notedetect/blob/main/tools/regression.js).
+- Plugin source: [`screen.js`](https://github.com/got-feedback/feedback-plugin-notedetect/blob/main/screen.js) — `matchNotes`, `checkMisses`, `_diagTimingErrors` / `_diagTimingErrorsHits`, `getDiagnostic`.
+- Routes: [`routes.py`](https://github.com/got-feedback/feedback-plugin-notedetect/blob/main/routes.py) — the `/api/plugins/note_detect/recording` and `/api/plugins/note_detect/live-judgment` endpoints.
+- Harness: [`tools/harness.js`](https://github.com/got-feedback/feedback-plugin-notedetect/blob/main/tools/harness.js).
+- Regression driver: [`tools/regression.js`](https://github.com/got-feedback/feedback-plugin-notedetect/blob/main/tools/regression.js).
 - Benchmark builder: [docs/benchmarks/note_detect_v1/build_benchmark.py](benchmarks/note_detect_v1/build_benchmark.py).
-- Settings UI: [`settings.html`](https://github.com/got-feedback/feedBack-plugin-notedetect/blob/main/settings.html) — A/V auto-calibrate panel, tuning-mode toggle, diagnostic block.
+- Settings UI: [`settings.html`](https://github.com/got-feedback/feedback-plugin-notedetect/blob/main/settings.html) — A/V auto-calibrate panel, tuning-mode toggle, diagnostic block.

docs/plugin-audio-mixer.md

@@ -0,0 +1,45 @@
+# Audio mixer fader registration
+
+Plugins that produce audio outside the song's `<audio>` element (NAM amp output, synth voices, etc.) can register a labeled fader so users can balance them against the song from one mixer popover in the player controls.
+
+This is the slopsmith#87 contract.
+
+## Registration
+
+```js
+function _registerFader() {
+    const api = window.slopsmith && window.slopsmith.audio;
+    if (!api) return;
+    api.registerFader({
+        id: 'my_plugin',           // unique key
+        label: 'My Plugin',        // shown above the fader
+        unit: 'dB',                // optional suffix shown next to the value (e.g. '%', 'dB')
+        min: 0, max: 2, step: 0.05,
+        defaultValue: 1.0,
+        getValue: () => _myCurrentVolume,        // read current value
+        setValue: (v) => _setMyVolume(v),         // write + persist + apply
+    });
+}
+
+if (window.slopsmith && window.slopsmith.audio) {
+    _registerFader();
+} else {
+    window.addEventListener('slopsmith:audio:ready', _registerFader, { once: true });
+}
+```
+
+## Contract
+
+- **Persistence is the plugin's responsibility.** The registry calls `getValue()` when the popover opens and after each `setValue()` during slider drags to re-sync the displayed value.
+- **`getValue()` must be cheap and side-effect-free.**
+- **`setValue()` must update whatever backing state `getValue()` reads synchronously** — pair it with whatever your plugin already does internally (write the GainNode, persist to `localStorage`, update any in-plugin label).
+- **Use `unregisterFader(id)`** when your plugin is teardown-able and you want the strip to disappear; otherwise keep it registered so the user's setting persists across toggle states.
+
+## Lifecycle event
+
+`slopsmith:audio:ready` fires once on `window` when the audio mixer registry is ready. Guard registration against this event for plugins that load before the mixer.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [plugin-visualization-contracts.md](plugin-visualization-contracts.md) — visualization counterpart

docs/plugin-capability-inventory.md

@@ -1,6 +1,6 @@
 # Plugin Capability Inventory
 
-This report inventories the currently included plugins staged in `plugins/` and maps their observed behavior to FeedBack capability domains. It is intended to inform the capability roadmap and the next migration specs now that PR1, the audio graph/session slice, playback, and audio-effects are active capability surfaces.
+This report inventories the currently included plugins staged in `plugins/` and maps their observed behavior to Slopsmith capability domains. It is intended to inform the capability roadmap and the next migration specs now that PR1, the audio graph/session slice, playback, and audio-effects are active capability surfaces.
 
 ## Scope And Method
 
@@ -8,7 +8,7 @@ This report inventories the currently included plugins staged in `plugins/` and
 - Verification pass: the original bundled-plugin scan found 25 plugins with backend `routes.py` and 14 plugins with `settings.html`. First-party plugin repos outside `plugins/` were checked separately from their current manifests and handoff docs.
 - Most bundled plugin entries below are still inferred/recommended declarations. Current first-party manifests now declare active capability intent for `diagnostics`, `pipeline`, `library`, `audio-mix`, `audio-input`, `audio-monitoring`, `stems`, `playback`, `audio-effects`, `jobs`, and privileged capability inventory surfaces where their repos have already migrated.
 - Manifest fields such as `nav`, `screen`, `settings`, `routes`, and `type: "visualization"` were treated as high-confidence evidence.
-- Code patterns such as `window.feedBackViz_*`, `window.playSong` wrappers, `window.showScreen` wrappers, `window.registerShortcut`, `window.feedBackTour.register`, `window.feedBack.audio.registerFader`, `highway.setNoteStateProvider`, and route/WebSocket handlers were treated as behavior evidence.
+- Code patterns such as `window.slopsmithViz_*`, `window.playSong` wrappers, `window.showScreen` wrappers, `window.registerShortcut`, `window.slopsmithTour.register`, `window.slopsmith.audio.registerFader`, `highway.setNoteStateProvider`, and route/WebSocket handlers were treated as behavior evidence.
 
 ## Roadmap Baseline
 
@@ -80,7 +80,7 @@ The plugin inventory confirms these planned domains are directionally right. The
 | `section_map` | `ui.player-overlays`, `playback` | overlay provider, observer | Planned | High | Highway section overlay behavior. |
 | `setlist` | `library`, `playback`, `ui.plugin-screens`, `backend.routes` | requester/provider, screen provider, route provider | Library/playback active; UI/routes planned | High | Setlist screen/routes and song selection/playback workflow. |
 | `sloppak_converter` | `media-import-export`, `jobs`, `library`, `ui.plugin-screens`, `backend.routes`, `ui.library-card-injection` | conversion provider, job provider, route provider | Library active; jobs/UI/routes planned; media/card missing | High | Converter routes, queue UI, library card actions, conversion jobs. |
-| `virtuoso` | `ui.plugin-screens`, `backend.routes`, `settings`, `visualization` | screen provider, route provider, observer | Active | High | Contained practice studio (scale/technique/rhythm drills, workouts, jam backing); borrows the 3D highway visualization. |
+| `slopscale` | `ui.plugin-screens`, `backend.routes`, `settings`, `visualization` | screen provider, route provider, observer | Planned | High | Routes/settings and 3D highway visualization observation. |
 | `song_preview` | `playback`, `audio-mix`, `ui.plugin-screens`, `backend.routes`, `settings` | preview provider, route provider, audio participant | Playback/audio-mix active; UI/routes planned | Medium | Preview screen/routes/settings and audio preview behavior. |
 | `splitscreen` | `ui.player-panels`, `ui.player-overlays`, `visualization`, `playback`, `keyboard-shortcuts`, `settings` | panel provider, observer, shortcut provider | Playback active; UI/visualization planned; shortcuts missing | High | Multi-highway panels, playback/screen wrappers, panel shortcuts/settings. |
 | `stem_mixer` | `stems`, `audio-mix`, `ui.plugin-screens`, `backend.routes`, `settings`, `jobs` | stem provider, mixer provider, route provider | Audio active; jobs planned | High | Stems mixer routes/settings and stem/audio mix ownership. |
@@ -231,11 +231,11 @@ For active domains, command and operation names should follow [capability-domain
 
 ## Highway String Colors (data-plane API)
 
-User-customizable per-string highway colors (the "Highway String Colors" setting in the 3D Highway plugin's panel) are **not** a capability domain. Consistent with `capability-domains.md` keeping highway-rendering and `visualization` surfaces off the capability graph until a dedicated render-facade slice lands, they are exposed as a synchronous **data-plane** API on `window.feedBack.highwayColors` plus a change event. Visualization/overlay plugins (custom highways, minigames, fretboard widgets) should read colors from here so their gems/strings match the user's theme.
+User-customizable per-string highway colors (the "Highway String Colors" setting in the 3D Highway plugin's panel) are **not** a capability domain. Consistent with `capability-domains.md` keeping highway-rendering and `visualization` surfaces off the capability graph until a dedicated render-facade slice lands, they are exposed as a synchronous **data-plane** API on `window.slopsmith.highwayColors` plus a change event. Visualization/overlay plugins (custom highways, minigames, fretboard widgets) should read colors from here so their gems/strings match the user's theme.
 
 Colors are keyed by **named string slot**, not raw index, so a string keeps its color across arrangements (Low E stays Low E's color on a 6-string guitar, 4-string bass, or 7/8-string, where the extra low strings use the `low7`/`low8` slots). Slots: `highE`, `B`, `G`, `D`, `A`, `lowE`, `low7` (7-string Low B), `low8` (8-string Low F#).
 
-`window.feedBack.highwayColors` (`version: 1`):
+`window.slopsmith.highwayColors` (`version: 1`):
 
 | Member | Returns | Purpose |
 |--------|---------|---------|
@@ -250,7 +250,7 @@ Colors are keyed by **named string slot**, not raw index, so a string keeps its
 | `encodeShare(name, map)` / `decodeShare(code)` | `string` / `{name,colors}` | The `SLOPHWY2.` copy/paste share format. |
 | `onChange(fn)` / `offChange(fn)` | unsubscribe fn | `fn(resolvedMap)` fires on any color change (also on song load when the slot→index mapping shifts). |
 
-The underlying change event is `window.feedBack.emit('highway:stringColors', …)`; `onChange` wraps it and hands back the resolved map. The raw `window.highway.getStringColors()` data-plane accessor (per-index) remains available for renderers that only need the current applied array. When a `visualization` capability slice eventually lands, this facade is the natural thing to fold into it.
+The underlying change event is `window.slopsmith.emit('highway:stringColors', …)`; `onChange` wraps it and hands back the resolved map. The raw `window.highway.getStringColors()` data-plane accessor (per-index) remains available for renderers that only need the current applied array. When a `visualization` capability slice eventually lands, this facade is the natural thing to fold into it.
 
 ## Validation Notes
 

docs/plugin-diagnostics.md

@@ -0,0 +1,86 @@
+# Plugin diagnostics contribution
+
+Slopsmith ships an **Export Diagnostics** feature (Settings → Export Diagnostics) that bundles a redacted set of host + plugin state into a zip the user can share with maintainers. Plugins have three independent opt-ins for contributing to this bundle.
+
+The bundle layout and per-file schemas are documented in [diagnostics-bundle-spec.md](diagnostics-bundle-spec.md). This doc covers how plugins integrate.
+
+## 1. `manifest.diagnostics.server_files` — opt-in file capture
+
+Declare files under `context["config_dir"]` to copy verbatim into the bundle:
+
+```json
+{
+  "diagnostics": {
+    "server_files": ["my_plugin.diag.json", "my_plugin_models/active.json"]
+  }
+}
+```
+
+Rules (same as `settings.server_files`):
+- Relpaths only. No `..`, no abs paths, no backslashes, no leading dots.
+- Files land at `plugins/<plugin_id>/<relpath>` inside the bundle.
+- Encoded as `{"encoding": "json", "data": <parsed>}` if `.json` parses cleanly, base64 otherwise.
+
+Use this for **snapshot-style state** — small DB excerpts, model lists, last-error files. Don't use it for backups (that's `settings.server_files`).
+
+## 2. `manifest.diagnostics.callable` — opt-in dynamic capture
+
+Declare a Python entry point that produces diagnostics at export time:
+
+```json
+{
+  "diagnostics": {
+    "callable": "diagnostics:collect"
+  }
+}
+```
+
+The form is `"<module>:<function>"`. The module is resolved lazily via `load_sibling` when the user clicks Export, then called as:
+
+```python
+# plugins/my_plugin/diagnostics.py
+def collect(ctx):
+    """ctx is {"plugin_id": str, "config_dir": Path}."""
+    return {
+        "schema": "my_plugin.diag.v1",
+        "active_preset": _read_active_preset(ctx["config_dir"]),
+        "model_count": len(list((ctx["config_dir"] / "models").glob("*.pt"))),
+    }
+```
+
+Return-type handling:
+- `dict` / `list` → written to `plugins/<id>/callable.json`
+- `bytes` → `callable.bin`
+- `str` → `callable.txt`
+
+Exceptions are caught and appended to the bundle's `manifest.notes` — a buggy plugin never crashes the export.
+
+## 3. Frontend contribution (slopsmith#166)
+
+Plugins that hold useful debug state in the browser (active model name, last user input, internal counters) can push it into the bundle from `screen.js`:
+
+```js
+window.slopsmith.diagnostics.contribute('my_plugin', {
+    schema: 'my_plugin.client_diag.v1',
+    active_preset: getActivePreset(),
+    last_error: _lastError,
+});
+```
+
+- **Idempotent.** Repeated calls overwrite the previous value.
+- Whatever was last contributed before the user hits Export Diagnostics is what lands in `plugins/<plugin_id>/client.json`.
+- Available namespace: `window.slopsmith.diagnostics.{contribute, snapshotConsole, snapshotHardware, snapshotUa, snapshotLocalStorage, snapshotContributions}`.
+- Loaded from `static/diagnostics.js` ASAP in `<head>` so the console-wrap is in place before any other script runs.
+
+## Best practices
+
+- **Embed a `schema` field** (e.g. `"my_plugin.diag.v1"`) in JSON returned by `callable` so future tooling can dispatch by version.
+- **Keep payloads small (< 100 KB).** Diagnostics are not a backup channel — that's `settings.server_files`.
+- **Don't include secrets, API keys, or session tokens.** Bundles are shared with maintainers / posted to GitHub issues.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [diagnostics-bundle-spec.md](diagnostics-bundle-spec.md) — full bundle layout + per-file schemas
+- [plugin-manifest.md](plugin-manifest.md) — declaring `diagnostics` fields
+- [plugin-logging.md](plugin-logging.md) — `log.exception()` writes traceback into the diagnostics log capture

docs/plugin-keyboard-shortcuts.md

@@ -0,0 +1,64 @@
+# Plugin keyboard shortcuts
+
+Plugins can register keyboard shortcuts via the global `window.registerShortcut()` function. Shortcuts appear in the `?` help panel.
+
+## Registration
+
+```js
+window.registerShortcut({
+    key: 'k',                       // key value (e.key) or key code (e.code)
+    description: 'Toggle my view',  // shown in the help panel
+    scope: 'player',                // 'global' | 'player' | 'library' | 'settings' | 'plugin-{id}'
+    condition: () => _isMyViewActive, // optional guard
+    handler: (e) => _myAction()      // called when shortcut triggers
+});
+```
+
+## Scope
+
+Scope controls when the shortcut is active:
+
+- **`global`** — works on any screen
+- **`player`** — only on the player screen
+- **`library`** — only on the home/favorites screens
+- **`settings`** — only on the settings screen
+- **`plugin-{id}`** — only when your plugin's screen is active
+
+## Panel-scoped shortcuts
+
+For plugins that create multiple panels (e.g., splitscreen), shortcuts are automatically scoped to the active panel. Use `const panel = window.createShortcutPanel(id)` to create a panel (keep the returned reference so you can call `panel.clearShortcuts()` during cleanup) and `window.setActiveShortcutPanel(id)` to switch between them. Each panel has its own shortcut registry, so multiple panels can have the same key without collisions.
+
+## Condition
+
+`condition` is an optional guard function. If it returns false, the shortcut is skipped even if in scope.
+
+## Key matching
+
+The handler matches against both `e.key` (character produced) and `e.code` (physical key). Use `e.key` for letters/symbols that depend on keyboard layout, and `e.code` for special keys (e.g. `Space`, `ArrowLeft`).
+
+## Cleanup
+
+Clean up with `window.unregisterShortcut(key, scope)`. **You must pass the same scope you registered with** — the default is `'global'` and won't match `player`/`library`/`settings`/`plugin-*` bindings.
+
+For panel-scoped shortcuts, prefer `panel.clearShortcuts()` over per-key unregister calls.
+
+## Built-in shortcuts
+
+| Key | Description |
+|-----|-------------|
+| `?` | Show keyboard shortcuts panel (global) |
+| `Space` | Play/Pause (player only) |
+| `←` / `→` | Seek ±5 seconds (player only) |
+| `Escape` | Back to library (player only) |
+| `[` / `]` | Audio offset ±10ms (Shift: ±50ms) (player only) |
+
+Don't override these. The `?` panel is the canonical reference for users.
+
+## Debugging
+
+Open the browser console and type `_listShortcuts()` to inspect every registered shortcut, its scope, and its source plugin.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [testing-plugins.md](testing-plugins.md) — Playwright tests for shortcut behaviour

docs/plugin-logging.md

@@ -0,0 +1,67 @@
+# Plugin logging
+
+Use `context["log"]` for all backend plugin output. It is a stdlib `logging.Logger` namespaced to `slopsmith.plugin.<id>`, pre-configured with the app-wide level, format (including JSON mode), and correlation IDs. **Never use `print()`** — it bypasses correlation context and log rotation.
+
+## Backend usage
+
+```python
+def setup(app, context):
+    log = context["log"]
+    log.info("plugin ready")
+    log.warning("optional dependency %r not found, feature disabled", dep)
+    try:
+        risky_init()
+    except Exception:
+        log.exception("unhandled error during setup")  # auto-captures traceback
+```
+
+## CLI entry-point fallback
+
+For helper scripts that also run as `__main__`, add a stdlib fallback so the logger works without the server pipeline:
+
+```python
+if __name__ == "__main__":
+    import logging
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
+```
+
+## How it's wired
+
+The plugin loader assigns each plugin a logger before calling `setup()`:
+
+```python
+context["log"] = logging.getLogger(f"slopsmith.plugin.{plugin_id}")
+```
+
+That logger inherits from the root `slopsmith` logger, which is configured by `logging_setup.configure_logging()` (called from `main.py` before uvicorn boots). It respects:
+
+- **`LOG_LEVEL`** — `DEBUG | INFO | WARNING | ERROR` (default `INFO`)
+- **`LOG_FORMAT`** — `json | text` (default `text` — coloured console)
+- **`LOG_FILE`** — optional path for a persistent log file (e.g. `/config/slopsmith.log`)
+- **Correlation IDs** — each HTTP request carries `X-Request-ID`; structlog injects it into every log line during that request's lifetime. WebSocket sessions get their own `ws_conn_id` contextvar bound at accept time.
+
+## Verifying
+
+Look for your plugin's logger name in the console output:
+
+```text
+INFO     slopsmith.plugin.my_plugin: plugin ready
+```
+
+Switch `LOG_FORMAT=json` to see structured output:
+
+```json
+{"timestamp": "...", "level": "info", "logger": "slopsmith.plugin.my_plugin", "event": "plugin ready", "request_id": "..."}
+```
+
+## Common mistakes
+
+- **Using `print()` inside `setup()` or request handlers.** `print()` goes to stdout, bypasses level filtering, log rotation, JSON formatting, and correlation IDs. Audit your plugin with `grep -nR 'print(' plugins/<id>/`.
+- **Creating a new logger with `logging.getLogger("my_plugin")`.** This creates an unparented logger that doesn't inherit slopsmith's configuration. Always use the one passed via `context["log"]`.
+- **Logging at `INFO` in hot paths.** Default `LOG_LEVEL` is `INFO`, so `log.info(...)` inside a per-frame or per-message loop floods output. Use `log.debug(...)` for hot-path tracing.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [plugin-manifest.md](plugin-manifest.md) — the `routes.py` / `setup(app, context)` contract
+- [plugin-diagnostics.md](plugin-diagnostics.md) — capturing logs into the diagnostics bundle

docs/plugin-manifest.md

@@ -0,0 +1,234 @@
+# `plugin.json` manifest reference
+
+Every plugin lives in `plugins/<name>/` and must declare a `plugin.json` manifest. JSON Schema for this format ships at [`schema/plugin.schema.json`](../schema/plugin.schema.json) and is enforced in CI for in-tree plugins.
+
+## Full example
+
+```json
+{
+  "id": "my_plugin",
+  "name": "My Plugin",
+  "version": "1.0.0",
+  "private": false,
+  "standards": ["capability-pipelines.v1", "plugin-runtime-idempotent.v1"],
+  "screen": "screen.html",
+  "script": "screen.js",
+  "styles": "assets/plugin.css",
+  "routes": "routes.py",
+  "settings": {
+    "html": "settings.html",
+    "server_files": ["my_plugin.db", "my_plugin_models/"]
+  },
+  "diagnostics": {
+    "server_files": ["my_plugin.diag.json"],
+    "callable": "diagnostics:collect"
+  },
+  "settings_schema": {
+    "schema_version": "1",
+    "packable_keys": ["enabled"]
+  },
+  "ui": {
+    "settings": [{ "id": "my-plugin-settings", "region": "plugin-settings", "label": "My Plugin" }],
+    "ui.plugin-screens": [{ "id": "my-plugin-screen", "region": "plugin.main", "label": "My Plugin" }]
+  },
+  "capabilities": {
+    "library": {
+      "roles": ["provider"],
+      "operations": ["query-page", "query-artists", "query-stats"],
+      "mode": "active",
+      "compatibility": "none",
+      "ownership": "multi-provider",
+      "safety": "safe",
+      "version": 1
+    }
+  }
+}
+```
+
+All fields except `id` and `name` are optional. Runtime files such as `screen`, `script`, `routes`, and `settings.html` should correspond to declared `capabilities`, `ui`, diagnostics, or settings metadata.
+
+## Fields
+
+### `id` (required, string)
+
+Snake-case identifier. Used to namespace `localStorage` keys, build the plugin's screen id (`plugin-<id>`), namespace the backend logger (`slopsmith.plugin.<id>`), and as the directory name in diagnostics bundles. Cannot contain slashes, dots are encoded by the sibling-import loader (see [plugin-sibling-imports.md](plugin-sibling-imports.md)).
+
+### `name` (required, string)
+
+Human-readable name shown in UI surfaces.
+
+### `version` (string, optional)
+
+Plain semver string. Advisory only — the plugin loader does not consume this. Plugins commonly include it for publishing/tooling purposes.
+
+### `private` (boolean, optional)
+
+Advisory metadata for plugin authors. Not consumed by the loader.
+
+### `standards` (string[], expected)
+
+Versioned contracts the plugin participates in. Plugin manifests are expected to declare `"capability-pipelines.v1"` for Slopsmith-facing behavior and metadata. Omit it only for metadata-only or transitional manifests with no capability participation yet.
+
+Declare `"plugin-runtime-idempotent.v1"` only when repeated script hydration cannot duplicate wrappers, listeners, timers, DOM roots, diagnostics contributors, jobs, media nodes, or capability participants.
+
+### `capability_api` (object, optional)
+
+Explicit capability API marker. Most plugins can use the compact `standards` form instead:
+
+```json
+{ "capability_api": { "standard": "capability-pipelines.v1", "version": 1 } }
+```
+
+### `screen` (string, optional)
+
+Path to HTML file (relative to plugin dir). Mounted at `#plugin-<id>` in the SPA.
+
+### `script` (string, optional)
+
+Path to JS file (relative to plugin dir). Loaded via `<script>` tag in global scope. Wrap in an IIFE.
+
+### `styles` (string, optional)
+
+Path to a plugin-owned compiled stylesheet under `assets/`, for example `"assets/plugin.css"`. Use this when a plugin ships Tailwind utilities that core's prebuilt stylesheet cannot know about, especially arbitrary-value classes in runtime-installed plugins. The stylesheet must be built ahead of time with Tailwind `preflight: false`; Slopsmith injects one versioned `<link>` for the plugin. See [plugin-styles.md](plugin-styles.md).
+
+### `routes` (string, optional)
+
+Path to Python file exporting `setup(app, context)`. See "Backend routes" below.
+
+### `settings` (object, optional)
+
+`{ "html": string, "server_files": string[] }`
+
+- **`settings.html`** — settings-panel HTML.
+- **`settings.server_files`** — **opt-in** for the unified Settings export/import flow (slopsmith#113). List of relpaths under `context["config_dir"]` that the plugin wants included in user-triggered backups. A trailing `/` denotes a directory (recurse).
+
+  Rules:
+  - Relpaths only. Absolute paths, drive letters, `..` segments, and backslashes are rejected at load time with a `[Plugin]` warning.
+  - The same allowlist is consulted at both export and import: a bundle that references a file the *importing host*'s manifest no longer declares is skipped with a warning (handles plugin updates between export and import). A bundle that references a file your host's manifest never declared is also skipped — no surprise writes.
+  - Files are encoded as `{"encoding": "json", "data": <parsed>}` for `.json` files that parse cleanly (diff-friendly), `{"encoding": "base64", "data": "..."}` otherwise (sqlite, model blobs, IRs).
+  - Plugins own their internal data migration. Importing a bundle whose data schema predates your current code restores bytes verbatim — your plugin must cope at next load.
+  - Symlinks are skipped on export and never followed on import.
+
+  Plugins that omit this field have no server-side files exported; their state lives entirely in browser `localStorage`, which is bundled wholesale on every export.
+
+### `diagnostics` (object, optional)
+
+`{ "server_files": string[], "callable": string }`
+
+**Opt-in** for the troubleshooting bundle (slopsmith#166 — Settings → Export Diagnostics). Two independent fields:
+
+- **`diagnostics.server_files`** — same allowlist semantics as `settings.server_files`: relpaths under `context["config_dir"]`, no `..`, no abs paths, no backslashes, no leading dots. Files listed here are copied verbatim into `plugins/<plugin_id>/<relpath>` inside the bundle. Use this for snapshot-style state (small DB excerpts, model lists, last-error files).
+- **`diagnostics.callable`** — `"<module>:<function>"` (e.g. `"diagnostics:collect"`). Resolved lazily via `load_sibling` when the user clicks Export, then called as `func({"plugin_id": "...", "config_dir": Path(...)})`. Return `dict`/`list` → written to `plugins/<id>/callable.json`; `bytes` → `callable.bin`; `str` → `callable.txt`. Exceptions are caught and appended to the bundle's `manifest.notes` — a buggy plugin never crashes the export.
+
+See [plugin-diagnostics.md](plugin-diagnostics.md) for full diagnostics integration patterns.
+
+### `settings_schema` (object, optional)
+
+Redaction-safe settings metadata for support tooling and capability diagnostics. Use this to describe schema/version and packable key names; do not store user settings values, paths, tokens, or plugin-private payloads here.
+
+### `ui` / `ui_contributions` (object, optional)
+
+Native UI contribution declarations keyed by UI domain or surface. Use these whenever a plugin contributes settings panels, plugin screens, player controls, overlays, tours, or other host-visible UI so Slopsmith can attribute UI to stable contribution records.
+
+Example:
+
+```json
+{
+  "ui": {
+    "settings": [{ "id": "my-plugin-settings", "region": "plugin-settings", "label": "My Plugin" }],
+    "ui.player-overlays": [{ "id": "my-plugin-overlay", "region": "player.overlays.highway", "label": "My Overlay" }]
+  }
+}
+```
+
+Contribution ids must be stable and unique per plugin. Keep metadata redaction-safe: no settings values, DOM handles, local paths, callbacks, or private payloads.
+
+### `capabilities` (object, expected for app-facing behavior)
+
+Native `capability-pipelines.v1` declarations keyed by capability domain. They describe what the plugin owns, provides, requests, observes, or emits before the runtime script hydrates, and are the default way plugin behavior is made visible to Slopsmith.
+
+```json
+{
+  "standards": ["capability-pipelines.v1"],
+  "capabilities": {
+    "library": {
+      "roles": ["provider"],
+      "operations": ["query-page", "query-artists", "query-stats", "tuning-names", "get-art", "sync-song"],
+      "description": "Adds a browsable library source.",
+      "mode": "active",
+      "compatibility": "none",
+      "ownership": "multi-provider",
+      "safety": "safe",
+      "version": 1
+    },
+    "playback": {
+      "roles": ["observer"],
+      "observes": ["loading", "ready", "stopped", "ended"],
+      "description": "Observes playback lifecycle through playback capability events.",
+      "mode": "active",
+      "compatibility": "none",
+      "ownership": "observer-only",
+      "safety": "safe",
+      "version": 1
+    }
+  }
+}
+```
+
+Supported declaration fields include:
+
+- `roles`: `owner`, `coordinator`, `provider`, `observer`, `requester`, `transformer`, `handler`, `validator`, `short-circuiter`, `contributor`
+- `commands`, `operations`, `requests`, `observes`, `emits`, `events`: string arrays naming public commands, provider operations, or events
+- `kind`: `command`, `provider-coordinator`, `event`, `diagnostic`, `privileged`
+- `mode`: `active`, `optional`, `legacy-shim`, `disabled`
+- `compatibility`: prefer `none` for new declarations
+- `ownership`: `exclusive-owner`, `multi-provider`, `observer-only`, `requester-only`, `privileged`, `diagnostic-only`
+- `safety`: `safe`, `privileged`, `sensitive`, `diagnostic-only`
+- `description` / `summary`: short redaction-safe text for local tooling
+- `version`: `1`
+
+Invalid capability metadata is rejected by schema validation and ignored by runtime capability tooling. Fix invalid metadata rather than relying on undocumented runtime behavior.
+
+### `license` (string, optional but recommended)
+
+SPDX identifier. Contributions must use `AGPL-3.0-only`. See [CONTRIBUTING.md](../CONTRIBUTING.md).
+
+## Backend routes — `setup(app, context)`
+
+`routes.py` must export `setup(app, context)`. The `context` dict provides:
+
+- `config_dir` — persistent config path (`Path`)
+- `get_dlc_dir()` — returns the DLC folder `Path`
+- `extract_meta()` — metadata extraction callable
+- `meta_db` — shared `MetadataDB` instance
+- `get_sloppak_cache_dir()` — sloppak cache `Path`
+- `load_sibling(name)` — loads a sibling module from this plugin's directory under a unique, namespaced module name. See [plugin-sibling-imports.md](plugin-sibling-imports.md).
+- `log` — stdlib `logging.Logger` namespaced to `slopsmith.plugin.<id>`. Pre-configured with the app-wide level, format (including JSON mode), and correlation IDs. Use this for all backend plugin output instead of `print()`. See [plugin-logging.md](plugin-logging.md).
+
+Prefer native capability declarations and provider registration for Slopsmith-facing behavior. Backend plugins should not open ad hoc SQLite connections to core databases or treat database tables as a public integration surface. If a legacy or core-provided route path already needs metadata access through `context["meta_db"]`, use the shared `MetadataDB` instance and its synchronized methods only; do not bypass its `threading.Lock` protection with direct SQLite access.
+
+Example:
+
+```python
+def setup(app, context):
+    log = context["log"]
+    extractor = context["load_sibling"]("extractor")
+
+    @app.get("/api/my_plugin/status")
+    def status():
+        return {"ready": True}
+
+    log.info("my_plugin ready")
+```
+
+## Validation
+
+Run the local validator skill `/plugin-validate` (Claude Code) or the CI workflow `.github/workflows/validate-plugins.yml`. Both consume [`schema/plugin.schema.json`](../schema/plugin.schema.json), including capability-pipelines metadata.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [plugin-logging.md](plugin-logging.md) — `context["log"]` pattern
+- [plugin-sibling-imports.md](plugin-sibling-imports.md) — `load_sibling`
+- [plugin-diagnostics.md](plugin-diagnostics.md) — diagnostics opt-in details
+- [diagnostics-bundle-spec.md](diagnostics-bundle-spec.md) — full diagnostics bundle layout

docs/plugin-manifest.schema.json

@@ -1,64 +1,398 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://feedBack.local/contracts/plugin-manifest-capabilities.schema.json",
-  "title": "FeedBack Plugin Manifest Capability Contract",
+  "$id": "https://slopsmith.local/contracts/plugin-manifest-capabilities.schema.json",
+  "title": "Slopsmith Plugin Manifest Capability Contract",
   "type": "object",
-  "required": ["id", "name"],
+  "required": [
+    "id",
+    "name"
+  ],
   "properties": {
-    "id": { "type": "string", "minLength": 1, "pattern": "^[A-Za-z0-9_.-]+$" },
-    "name": { "type": "string", "minLength": 1 },
-    "version": { "type": ["string", "null"] },
-    "private": { "type": "boolean" },
-    "standards": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
+    "id": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^[A-Za-z0-9_.-]+$"
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1
+    },
+    "version": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "private": {
+      "type": "boolean"
+    },
+    "standards": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      },
+      "uniqueItems": true
+    },
     "capability_api": {
       "type": "object",
-      "properties": { "standard": { "const": "capability-pipelines.v1" }, "version": { "const": 1 } },
+      "properties": {
+        "standard": {
+          "const": "capability-pipelines.v1"
+        },
+        "version": {
+          "const": 1
+        }
+      },
       "additionalProperties": false
     },
     "capabilities": {
       "type": "object",
-      "propertyNames": { "$ref": "#/$defs/domainName" },
-      "additionalProperties": { "$ref": "#/$defs/capabilityDeclaration" }
+      "propertyNames": {
+        "$ref": "#/$defs/domainName"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/capabilityDeclaration"
+      }
     },
-    "ui_contributions": { "type": "object", "propertyNames": { "$ref": "#/$defs/domainName" }, "additionalProperties": { "$ref": "#/$defs/contributionList" } },
-    "ui": { "type": "object", "propertyNames": { "$ref": "#/$defs/domainName" }, "additionalProperties": { "$ref": "#/$defs/contributionList" } },
-    "runtime_domains": { "type": "object", "propertyNames": { "$ref": "#/$defs/domainName" }, "additionalProperties": { "$ref": "#/$defs/domainDeclaration" } },
-    "domains": { "type": "object", "propertyNames": { "$ref": "#/$defs/domainName" }, "additionalProperties": { "$ref": "#/$defs/domainDeclaration" } },
-    "settings_schema": { "type": "object" },
-    "nav": {}, "screen": {}, "script": {}, "routes": {}, "settings": {}, "diagnostics": {}, "type": { "type": "string" }, "tour": {},
-    "description": { "type": "string", "description": "Short one-sentence summary of the plugin, surfaced on the v3 Pedalboard Plugins page (clamped to ~2 lines). Optional and additive." },
-    "category": { "type": "string", "description": "Which pedalboard the plugin sits on in the v3 Plugins page. Suggested values: 'audio', 'creation', 'practice', 'game', 'tools'. Free-form; unknown/absent values fall back to a curated default then 'other'. Optional and additive." },
-    "icon": { "type": "string", "minLength": 1, "pattern": "^assets/(?!.*\\.\\.)[^\\\\?#]+$", "description": "Plugin-root-relative path under assets/ (e.g. 'assets/thumb.png') to a thumbnail (~square, ~256x256 PNG/SVG) shown as the pedal graphic on the v3 Plugins page. Same containment rule as `styles`. If omitted, the loader auto-detects assets/thumb.png; failing that the UI shows a default pedal graphic. Optional and additive." },
-    "styles": { "type": "string", "minLength": 1, "pattern": "^assets/(?!.*\\.\\.)[^\\\\?#]+$", "description": "Plugin-root-relative path under assets/ (e.g. 'assets/plugin.css') to a compiled, preflight-off Tailwind stylesheet the frontend injects as a <link>. Must stay under assets/ with no '..', backslash, or query/fragment. See docs/plugin-styles.md." }
+    "ui_contributions": {
+      "type": "object",
+      "propertyNames": {
+        "$ref": "#/$defs/domainName"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/contributionList"
+      }
+    },
+    "ui": {
+      "type": "object",
+      "propertyNames": {
+        "$ref": "#/$defs/domainName"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/contributionList"
+      }
+    },
+    "runtime_domains": {
+      "type": "object",
+      "propertyNames": {
+        "$ref": "#/$defs/domainName"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/domainDeclaration"
+      }
+    },
+    "domains": {
+      "type": "object",
+      "propertyNames": {
+        "$ref": "#/$defs/domainName"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/domainDeclaration"
+      }
+    },
+    "settings_schema": {
+      "type": "object"
+    },
+    "nav": {},
+    "screen": {
+      "$ref": "#/$defs/pluginRelpath"
+    },
+    "script": {
+      "$ref": "#/$defs/pluginRelpath"
+    },
+    "routes": {
+      "$ref": "#/$defs/pluginRelpath"
+    },
+    "settings": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "html": {
+          "$ref": "#/$defs/pluginRelpath"
+        },
+        "server_files": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "not": {
+              "pattern": "^/|^[a-zA-Z]:|\\\\|(^|/)\\.\\.(/|$)|//|(^|/)\\.(/|$)|^\\."
+            }
+          },
+          "uniqueItems": true
+        }
+      }
+    },
+    "diagnostics": {},
+    "type": {
+      "type": "string"
+    },
+    "tour": {
+      "$ref": "#/$defs/pluginRelpath"
+    },
+    "description": {
+      "type": "string",
+      "description": "Short one-sentence summary of the plugin, surfaced on the v3 Pedalboard Plugins page (clamped to ~2 lines). Optional and additive."
+    },
+    "category": {
+      "type": "string",
+      "description": "Which pedalboard the plugin sits on in the v3 Plugins page. Suggested values: 'audio', 'creation', 'practice', 'game', 'tools'. Free-form; unknown/absent values fall back to a curated default then 'other'. Optional and additive."
+    },
+    "icon": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^assets/(?!.*\\.\\.)[^\\\\?#]+$",
+      "description": "Plugin-root-relative path under assets/ (e.g. 'assets/thumb.png') to a thumbnail (~square, ~256x256 PNG/SVG) shown as the pedal graphic on the v3 Plugins page. Same containment rule as `styles`. If omitted, the loader auto-detects assets/thumb.png; failing that the UI shows a default pedal graphic. Optional and additive."
+    },
+    "styles": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^assets/(?!.*\\.\\.)[^\\\\?#]+$",
+      "description": "Plugin-root-relative path under assets/ (e.g. 'assets/plugin.css') to a compiled, preflight-off Tailwind stylesheet the frontend injects as a <link>. Must stay under assets/ with no '..', backslash, query, or fragment. See docs/plugin-styles.md."
+    }
   },
   "additionalProperties": true,
   "$defs": {
-    "domainName": { "type": "string", "minLength": 1, "pattern": "^[A-Za-z0-9_.:-]+$" },
+    "pluginRelpath": {
+      "type": "string",
+      "minLength": 1,
+      "not": {
+        "pattern": "^/|^[a-zA-Z]:|\\\\|(^|/)\\.\\.(/|$)|//|(^|/)\\.(/|$)|^\\.|[?#]"
+      }
+    },
+    "domainName": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^[A-Za-z0-9_.:-]+$"
+    },
     "capabilityDeclaration": {
       "type": "object",
       "properties": {
-        "roles": { "type": "array", "items": { "enum": ["owner", "provider", "observer", "requester", "transformer", "handler", "validator", "short-circuiter", "contributor"] }, "uniqueItems": true },
-        "commands": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
-        "operations": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
-        "requests": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
-        "observes": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
-        "emits": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
-        "events": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
-        "kind": { "enum": ["command", "provider-coordinator", "event", "diagnostic", "privileged"] },
-        "mode": { "enum": ["active", "optional", "legacy-shim", "disabled"] },
-        "compatibility": { "enum": ["none", "shim-allowed", "degrade-noop", "required", "legacy-window-shim"] },
-        "ownership": { "enum": ["exclusive-owner", "multi-provider", "observer-only", "requester-only", "privileged", "diagnostic-only"] },
-        "safety": { "enum": ["safe", "privileged", "sensitive", "diagnostic-only"] },
-        "order": { "type": "object", "properties": { "fixed": { "type": "boolean" }, "before": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true }, "after": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true } }, "additionalProperties": false },
-        "provider_policy": { "type": "object" },
-        "settings": { "type": "array", "description": "Declarative per-instance control descriptors (toggle / range / select) a participant exposes for a consuming host to render generically. Domain-agnostic in shape; how a host applies a chosen value is defined by each capability domain's contract (the visualization domain requires an applySetting(key, value) method on the renderer instance).", "items": { "type": "object", "required": ["key", "type"], "properties": { "key": { "type": "string", "minLength": 1 }, "label": { "type": "string" }, "type": { "enum": ["toggle", "range", "select"] }, "default": {}, "min": { "type": "number" }, "max": { "type": "number" }, "step": { "type": "number" }, "options": { "type": "array", "items": { "type": "object", "required": ["id"], "properties": { "id": { "type": "string", "minLength": 1 }, "label": { "type": "string" } }, "additionalProperties": false } } }, "additionalProperties": false } },
-        "description": { "type": "string" },
-        "summary": { "type": "string" },
-        "version": { "const": 1 }
+        "roles": {
+          "type": "array",
+          "items": {
+            "enum": [
+              "owner",
+              "coordinator",
+              "provider",
+              "observer",
+              "requester",
+              "transformer",
+              "handler",
+              "validator",
+              "short-circuiter",
+              "contributor"
+            ]
+          },
+          "uniqueItems": true
+        },
+        "commands": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "uniqueItems": true
+        },
+        "operations": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "uniqueItems": true
+        },
+        "requests": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "uniqueItems": true
+        },
+        "observes": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "uniqueItems": true
+        },
+        "emits": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "uniqueItems": true
+        },
+        "events": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "uniqueItems": true
+        },
+        "kind": {
+          "enum": [
+            "command",
+            "provider-coordinator",
+            "event",
+            "diagnostic",
+            "privileged"
+          ]
+        },
+        "mode": {
+          "enum": [
+            "active",
+            "optional",
+            "legacy-shim",
+            "disabled"
+          ]
+        },
+        "compatibility": {
+          "enum": [
+            "none",
+            "shim-allowed",
+            "degrade-noop",
+            "required",
+            "legacy-window-shim"
+          ]
+        },
+        "ownership": {
+          "enum": [
+            "exclusive-owner",
+            "multi-provider",
+            "observer-only",
+            "requester-only",
+            "privileged",
+            "diagnostic-only"
+          ]
+        },
+        "safety": {
+          "enum": [
+            "safe",
+            "privileged",
+            "sensitive",
+            "diagnostic-only"
+          ]
+        },
+        "order": {
+          "type": "object",
+          "properties": {
+            "fixed": {
+              "type": "boolean"
+            },
+            "before": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "minLength": 1
+              },
+              "uniqueItems": true
+            },
+            "after": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "minLength": 1
+              },
+              "uniqueItems": true
+            }
+          },
+          "additionalProperties": false
+        },
+        "provider_policy": {
+          "type": "object"
+        },
+        "description": {
+          "type": "string"
+        },
+        "summary": {
+          "type": "string"
+        },
+        "version": {
+          "const": 1
+        }
       },
       "additionalProperties": false
     },
-    "domainDeclaration": { "oneOf": [{ "type": "object", "properties": { "role": { "type": "string", "minLength": 1 }, "roles": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "ownership": { "enum": ["exclusive-owner", "multi-provider", "observer-only", "requester-only", "privileged", "diagnostic-only"] }, "safety": { "enum": ["safe", "privileged", "sensitive", "diagnostic-only"] }, "legacy_source": { "type": "string", "minLength": 1 } }, "additionalProperties": true }, { "type": "array" }] },
-    "contributionList": { "type": "array", "items": { "type": "object", "required": ["id"], "properties": { "id": { "type": "string", "minLength": 1 }, "region": { "type": "string", "minLength": 1 }, "label": { "type": "string" }, "order": { "type": ["number", "integer", "string"] } }, "additionalProperties": true } }
+    "domainDeclaration": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "role": {
+              "type": "string",
+              "minLength": 1
+            },
+            "roles": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "minLength": 1
+              }
+            },
+            "ownership": {
+              "enum": [
+                "exclusive-owner",
+                "multi-provider",
+                "observer-only",
+                "requester-only",
+                "privileged",
+                "diagnostic-only"
+              ]
+            },
+            "safety": {
+              "enum": [
+                "safe",
+                "privileged",
+                "sensitive",
+                "diagnostic-only"
+              ]
+            },
+            "legacy_source": {
+              "type": "string",
+              "minLength": 1
+            }
+          },
+          "additionalProperties": true
+        },
+        {
+          "type": "array"
+        }
+      ]
+    },
+    "contributionList": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "id"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "minLength": 1
+          },
+          "region": {
+            "type": "string",
+            "minLength": 1
+          },
+          "label": {
+            "type": "string"
+          },
+          "order": {
+            "type": [
+              "number",
+              "integer",
+              "string"
+            ]
+          }
+        },
+        "additionalProperties": true
+      }
+    }
   }
 }

docs/plugin-sibling-imports.md

@@ -0,0 +1,48 @@
+# Plugin sibling imports — `load_sibling`
+
+When a backend plugin spans multiple Python files, **use `context["load_sibling"]`** rather than bare `import` statements. This is the slopsmith#33 contract.
+
+## The problem
+
+The plugin loader inserts each plugin's directory onto `sys.path` so `from extractor import X` works. But Python caches imports by **module name** in `sys.modules`. Two plugins that each ship a top-level `extractor.py` (or any other generic name — `util.py`, `client.py`, `parser.py`, `config.py`, …) collide: whichever loads first wins, and the other plugin's `from extractor import X` either gets the wrong module or fails with `cannot import name 'X' from 'extractor'`.
+
+## The fix
+
+`context["load_sibling"](name)` loads the sibling under a namespaced module name `plugin_<id>.<name>`, so each plugin gets its own copy. The `<id>` portion is bijectively encoded so reverse-DNS-style ids like `com.example.foo` work without colliding: `_` → `_5f_`, `.` → `_2e_`.
+
+```python
+def setup(app, context):
+    extractor = context["load_sibling"]("extractor")
+    ArchiveReader = extractor.ArchiveReader
+    # …
+```
+
+## Notes
+
+- **`name` is a bare module name** — no `.py` suffix, no slashes, no `.`. The helper raises `ValueError` for path traversal / format issues and `ImportError` for missing files.
+- **Both single-file siblings (`extractor.py`) and package-form siblings (`extractor/__init__.py`) work.** Package form wins when both exist (matches CPython's import-resolution precedence).
+- **Relative imports between siblings work** — `from .shared import X` in a top-level helper, `from ..shared import X` from inside a sibling package. The synthetic parent package `plugin_<id>` carries the plugin directory in its `__path__`.
+- **`from . import sibling` (attribute-style) also resolves**: loaded children are exposed as attributes on the parent package.
+- **Repeat calls return the cached module.** Concurrent first-time calls are serialized via per-module locks so no caller observes a half-initialized module.
+- **Don't mix `load_sibling` and bare `import` for the same module** — they'd execute the file twice and split module-level state.
+
+## Migration
+
+Bare `import sibling` from `routes.py` still works during the transition period, but the loader prints a startup warning when it detects two plugins shipping a same-named top-level module — covering both `.py` files and package directories. Migrate to `load_sibling` to silence the warning and immunize your plugin from future ecosystem collisions.
+
+## Verification
+
+The collision-detection logic is encoded in `tests/test_plugins.py`. Run:
+
+```bash
+pytest tests/test_plugins.py -v
+```
+
+If you're authoring a plugin with a top-level helper, add a test that imports your plugin under a `reset_plugin_state` fixture to confirm clean import behaviour. See [testing-plugins.md](testing-plugins.md).
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [plugin-manifest.md](plugin-manifest.md) — declaring `routes.py`
+- [plugin-logging.md](plugin-logging.md) — `context["log"]` (also exposed via `context`)
+- [testing-plugins.md](testing-plugins.md) — `reset_plugin_state` fixture

docs/plugin-styles.md

@@ -1,14 +1,14 @@
 # Plugin styling — the `styles` capability
 
-> Building for the redesigned **v3 UI** (`FEEDBACK_UI=v3` / `/v3`)? v3 uses `fb-*`
+> Building for the redesigned **v3 UI** (`SLOPSMITH_UI=v3` / `/v3`)? v3 uses `fb-*`
 > design tokens and a restructured player chrome with a dedicated plugin-control
 > slot. See **[plugin-v3-ui.md](plugin-v3-ui.md)** for the player-chrome contract
 > plugins must follow in v3.
 
-FeedBack serves Tailwind as a **prebuilt** stylesheet
+Slopsmith serves Tailwind as a **prebuilt** stylesheet
 (`static/tailwind.min.css`), never the runtime Play CDN. The CDN's on-the-fly
 JIT rescanned the DOM on the main thread and dropped ~26% of frames with the 3D
-highway running (feedBack-desktop#110). See **constitution Principle II**.
+highway running (slopsmith-desktop#110). See **constitution Principle II**.
 
 A prebuilt stylesheet only contains the classes the build scanner saw in **core
 source at core build time**. That has a consequence for plugins:

docs/plugin-v3-ui.md

@@ -1,12 +1,12 @@
 # Building plugins for the v3 UI (fee[dB]ack v0.3.0)
 
-v0.3.0 ("fee[dB]ack") ships a redesigned UI **behind a flag** — `FEEDBACK_UI=v3`
+v0.3.0 ("fee[dB]ack") ships a redesigned UI **behind a flag** — `SLOPSMITH_UI=v3`
 or the `/v3` route. The classic UI (v2) remains the default until 0.3.0 ships, so
 plugins must work in **both**.
 
 The good news: v3 **reuses the same engine** as v2 — same `server.py`, `app.js`,
 `highway.js`, `playSong`, `showScreen`, capability registry, library providers,
-and the `window.feedBackViz_<id>` / `setRenderer` visualization contract. So your
+and the `window.slopsmithViz_<id>` / `setRenderer` visualization contract. So your
 plugin's **backend, capabilities, library providers, `nav`/`screen`, visualization
 renderers, diagnostics, and settings export all work unchanged in v3.** v3 surfaces
 your `nav` entry in the new sidebar (via `shell.js` `renderPluginNav`) and your
@@ -34,8 +34,8 @@ So the legacy way of injecting a control breaks in v3 two ways:
 
 The host exposes:
 
-- `window.feedBack.uiVersion === 'v3'` — detect v3 (absent / not `'v3'` in v2).
-- `window.feedBack.ui.playerControlSlot()` — returns a **stable, always-reachable
+- `window.slopsmith.uiVersion === 'v3'` — detect v3 (absent / not `'v3'` in v2).
+- `window.slopsmith.ui.playerControlSlot()` — returns a **stable, always-reachable
   container** (the "Plugins" rail popover). In v3, append your control(s) here
   instead of `#player-controls`.
 
@@ -43,9 +43,9 @@ Canonical pattern for any control you inject into the player:
 
 ```js
 function playerSlot() {
-  return (window.feedBack && window.feedBack.uiVersion === 'v3'
-    && window.feedBack.ui && typeof window.feedBack.ui.playerControlSlot === 'function')
-    ? window.feedBack.ui.playerControlSlot() : null;
+  return (window.slopsmith && window.slopsmith.uiVersion === 'v3'
+    && window.slopsmith.ui && typeof window.slopsmith.ui.playerControlSlot === 'function')
+    ? window.slopsmith.ui.playerControlSlot() : null;
 }
 
 function injectMyButton() {
@@ -183,7 +183,7 @@ out of the capability graph.
 - [ ] Backend / capabilities / library provider / `nav` + `screen` /
       visualization renderer — **no change needed** (they work in v3 as-is).
 - [ ] If you inject a control into the player: detect v3 and mount into
-      `window.feedBack.ui.playerControlSlot()`; drop the dead separator /
+      `window.slopsmith.ui.playerControlSlot()`; drop the dead separator /
       `button:last-child` anchor; guard `contains()` against the actual container.
 - [ ] Dropdowns positioned via `getBoundingClientRect()`, not `#player-controls`.
 - [ ] `#player` overlays keep `z-index` ≤ the chrome layers (transport/HUD 20,

docs/plugin-visualization-contracts.md

@@ -0,0 +1,198 @@
+# Plugin visualization contracts
+
+Slopsmith supports two ways for a plugin to participate in the main player's visuals. They coexist; the **setRenderer** contract is the default for any viz that draws a highway-shaped surface, and **overlays** handle layered decorations on top. A third orthogonal contract — **note-state provider** — lets scorers feed per-note judgments back into whichever renderer is active.
+
+**Pick the right shape:**
+- Replacing the whole highway drawing on the existing highway canvas (your renderer owns its rendering context / resources; `createHighway()` still owns the canvas element and the rAF loop)? → **setRenderer** (section 1). Enters the viz picker. Works in both the main player and per-panel under splitscreen.
+- Adding a layer on top of whichever viz is active? → **Overlay** (section 2). Navbar toggle, not in the picker.
+- Scoring plugin that wants renderers to "light up" notes on correct hits? → **Note-state provider** (section 3). Orthogonal — can coexist with overlay HUDs.
+
+## 1. setRenderer contract (slopsmith#36) — preferred
+
+Plugins that want to replace the main highway's draw function (per panel, per session) export a renderer factory on `window.slopsmithViz_<id>` where `<id>` matches the `id` in `plugin.json` (`type: "visualization"` required). The factory returns an object matching this shape:
+
+```js
+window.slopsmithViz_my_viz = function () {
+    return {
+        // Required canvas context type. Default '2d' if omitted.
+        // highway.js reads this BEFORE calling init() so it can
+        // replace the underlying <canvas> element if the current
+        // one is locked to a different context type (see "Canvas
+        // context-type swapping" below).
+        contextType: '2d', // or 'webgl2'
+        init(canvas, bundle) {
+            // One-time setup. Own your getContext() call here —
+            // acquire '2d' or 'webgl2' depending on the renderer.
+            // The canvas you receive is guaranteed to either be
+            // unbound or already bound to your declared contextType.
+            this.ctx = canvas.getContext('2d');
+        },
+        draw(bundle) {
+            // Called each requestAnimationFrame tick by the factory.
+            // `bundle` is a snapshot with: currentTime, songInfo, isReady,
+            // notes, chords, anchors (all difficulty-filter-aware),
+            // beats, sections, chordTemplates, stringCount, lyrics,
+            // toneChanges, toneBase, mastery, hasPhraseData, inverted,
+            // lefty, renderScale, lyricsVisible, the 2D coordinate
+            // helpers project and fretX, and getNoteState (see below).
+            // `stringCount` is the active arrangement's string count (4
+            // for bass, 6 for guitar, 7+ for extended-range GP imports —
+            // size string-indexed geometry against this, not a hardcoded
+            // 6). If your renderer needs lefty-aware text rendering, check
+            // bundle.lefty and apply the mirror transform yourself —
+            // a bundle-level helper isn't provided because it would
+            // need your renderer's own context, not the factory's.
+            //
+            // bundle.getNoteState(note, chartTime) (slopsmith#254) — call
+            // this per visible chart note / chord-note to find out whether
+            // a scorer (note_detect) has flagged it 'hit' / 'active' (a
+            // sustain currently being held correctly) / 'miss', so the gem
+            // itself can light up / a held sustain can glow instead of
+            // relying on an overlay ring. Returns null when no provider is
+            // registered or it reports nothing for this note; otherwise
+            // { state: 'hit'|'active'|'miss', alpha: 0..1, color: string|null }.
+            // For chord notes pass the chord's time (note_detect keys its
+            // judgments by `${time}_${string}_${fret}`). 'hit' and 'active'
+            // are both "lit" — a renderer may treat them identically; the
+            // provider owns all fade timing via `alpha` and by simply
+            // ceasing to return state when the effect should end.
+        },
+        resize(w, h) {
+            // Optional. Canvas dims already updated; re-create WebGL
+            // framebuffers / reset 2D transforms here.
+        },
+        destroy() {
+            // Optional. Release resources, remove DOM nodes, null refs.
+            // Called before setRenderer() swaps to another renderer
+            // and on highway.stop().
+        },
+    };
+};
+```
+
+Selecting this plugin in the main-player viz picker — or in splitscreen's per-panel picker — calls `highway.setRenderer(factory())` on the existing highway instance. The built-in 2D highway is the default renderer and is restored by passing nullish — `setRenderer(null)` and `setRenderer(undefined)` both work (the implementation gates on `r == null`). Splitscreen panels create one `createHighway()` per panel and each independently consults the picker, so N panels can run different renderers (or N copies of the same renderer with different arrangements) without coordination.
+
+### Lifecycle contract
+
+The factory returns a single renderer instance that may go through multiple `init() → ... → destroy()` cycles as the user navigates between songs or screens. Specifically:
+
+- `init(canvas, bundle)` runs when the highway has a canvas and the renderer takes over drawing. This is when to acquire `getContext()`, build shaders / meshes / DOM nodes, and register listeners.
+- `draw(bundle)` runs on every rAF frame once the WebSocket `ready` message has fired and until the renderer is replaced or the highway stops. It is **not** called during the loading / reconnect window (between `api.init()` + `stop()` and the next `ready`) — that would hand the renderer half-populated chart arrays. Renderers that want to show a "loading" state can read `bundle.isReady` inside a future-widened contract, but today the factory gates `draw` behind the ready flag and `isReady` is only informational once it does fire.
+- `destroy()` runs when the renderer is replaced via another `setRenderer(...)` call, OR when `highway.stop()` is called (e.g. the user navigates away from the player). It releases everything `init()` acquired.
+- **After `destroy()`, the same instance may receive another `init()` call** — this happens on `playSong()` which does `stop()` → `init()` to reuse the same canvas element for the next song. Renderers must tolerate `init()` being called again on an instance that was previously destroyed. Practically: null your refs in destroy, re-acquire them in init.
+- `destroy()` is skipped when it would run on an un-init'd renderer — if a caller does `setRenderer(x)` before the highway ever init'd (possible when restoring a saved picker selection at page load), `x.destroy()` is not called until `x.init()` has run at least once.
+- `resize(w, h)` is optional; runs after init and whenever the canvas dimensions change.
+
+### Key rules
+
+- The factory **returns a fresh object on each call** — important for splitscreen, where multiple panels will each get an independent instance.
+- The renderer **owns its own rendering context** (2D or WebGL). Factory will not call getContext for you.
+- **Canvas context-type swapping.** Browsers lock a `<canvas>` to the first context type successfully acquired for its lifetime: once `getContext('2d')` succeeds, `getContext('webgl2')` on that same canvas returns `null`, and vice versa. To let arbitrary 2D ⇄ WebGL renderer swaps work mid-session, `highway.setRenderer()` reads the next renderer's `contextType` before calling its `init()` and, if it differs from the type currently bound, replaces the underlying `<canvas>` element with a fresh one via `oldCanvas.cloneNode(false)` followed by `oldCanvas.replaceWith(newCanvas)`. The factory then calls the renderer's `init(newCanvas, bundle)` with the fresh element so its `getContext()` succeeds. Practical implications:
+  - **What survives the swap.** `cloneNode(false)` preserves *every HTML attribute* on the element — `id`, `class`, inline `style`, all `data-*` and `aria-*` attributes, `role`, `tabindex`, the attribute form of `width`/`height`, and anything else a plugin attached. DOM position is preserved by `replaceWith()`, so siblings, parents, and surrounding layout are unaffected.
+  - **What does NOT survive.** Event listeners attached via `addEventListener` are NOT cloned, and expando properties set imperatively on the JavaScript object (such as the bound rendering context, or any `canvas._myPlugin = …`-style data a plugin attached) are not carried over either. The bound rendering context being left behind on the detached element is exactly what allows the new canvas to start fresh and accept a different `getContext()` call. Note: `canvas.width`/`canvas.height` *are* reflected HTML attributes, so those values do survive the clone; `api.resize()` re-applies the backing-store dimensions on the new element after the swap regardless.
+  - Renderers must **declare `contextType`** on the returned instance (`'2d'` or `'webgl2'`; absent → `'2d'`). Factories may also expose it as a static (`window.slopsmithViz_<id>.contextType = 'webgl2'`) so core can read it before constructing the renderer — used today by Auto-mode evaluation.
+  - Plugins that hold a stale reference to the highway canvas across renderer swaps — including any code that registered listeners directly on the canvas element rather than on `window`/`document` — should listen for the `highway:canvas-replaced` event on `window.slopsmith` and re-acquire / re-register. `window.slopsmith.emit` dispatches a `CustomEvent`, so the payload `{ oldCanvas, newCanvas, contextType }` lives on `event.detail`, not on the event object itself:
+    ```js
+    window.slopsmith.on('highway:canvas-replaced', (event) => {
+        const { oldCanvas, newCanvas, contextType } = event.detail;
+        // re-acquire / re-register against newCanvas
+    });
+    ```
+    Plugins that re-query `document.getElementById('highway')` lazily inside their own event handlers don't need this listener — they pick up the new element automatically (it keeps `id="highway"`).
+  - **`highway:visibility`** — fired on `window.slopsmith` whenever the highway canvas transitions between displayed and hidden. Detection is DOM-based via `canvas.offsetParent === null` (catches `display:none` on the canvas or any ancestor — e.g. splitscreen's `#highway` hide) or whatever a host explicitly sets via `highway.setVisible(bool)`. While `visible === false`, core skips the rAF `renderer.draw(bundle)` call AND the default 2D draw, so renderers don't have to no-op themselves. The event is emitted only on transitions (including the first one after `init()`), not every frame. Payload `{ visible, canvas }` lives on `event.detail`:
+    ```js
+    window.slopsmith.on('highway:visibility', (event) => {
+        const { visible, canvas } = event.detail;
+        // Toggle any sibling DOM your renderer mounts. The 3D Highway
+        // renderer hides its `.h3d-wrap` overlay here so `display:none`
+        // on `#highway` actually hides the visible output.
+    });
+    ```
+    Renderers that only paint to the slopsmith canvas don't need this listener — the rAF skip is enough. Renderers that mount sibling DOM (separate WebGL contexts, overlays, etc.) do.
+  - **`highway.setVisible(bool | null)`** — forces the visibility state regardless of `offsetParent`. Pass `null` to clear the override and resume DOM-based detection. Useful when the host hides the highway via `visibility:hidden`, `opacity:0`, transforms, or clipping rather than `display:none`. The override re-emits any resulting transition immediately rather than waiting for the next rAF tick.
+  - Default-renderer ctx is closure-cached. The replace path nulls the closure ctx so stale draw paths short-circuit; the next default-renderer `init()` re-acquires the 2D context from the new canvas cleanly.
+- `draw(bundle)` receives difficulty-filtered arrays — never read from `_filteredNotes` or other internals.
+- `_drawHooks` fire for the default 2D renderer (the factory calls them at the end of each frame). Custom WebGL renderers that maintain a 2D overlay canvas (like the bundled 3D highway) also call `window.highway.fireDrawHooks(ctx, W, H)` on that overlay so overlay plugins continue to work regardless of which renderer is active. Custom renderers without a 2D overlay context should not attempt to fire hooks.
+
+### Auto mode — `matchesArrangement(songInfo)` (optional)
+
+The viz picker prepends an "Auto (match arrangement)" entry that is the default selection on fresh installs. When Auto is active, core evaluates registered viz factories on every `song:ready` and swaps the renderer to the first factory whose `matchesArrangement(songInfo)` predicate returns truthy. No match → the built-in 2D highway.
+
+Declare the predicate as a static on the factory (not the instance) so core can evaluate it without constructing a throwaway renderer:
+
+```js
+window.slopsmithViz_piano = function () { /* ... */ };
+window.slopsmithViz_piano.matchesArrangement = function (songInfo) {
+    return /keys|piano|synth/i.test((songInfo && songInfo.arrangement) || '');
+};
+```
+
+- `songInfo` is the highway's live song_info snapshot — `arrangement`, `tuning`, `capo`, `arrangement_index`, `filename`, `artist`, `title`, etc. May be `{}` before the first song loads.
+- Factories without `matchesArrangement` are skipped during auto-selection — the correct default for arrangement-agnostic viz (tabview, jumpingtab) that only make sense as manual picks.
+- Explicit picker selections override Auto and are persisted to `localStorage.vizSelection`, so the pinned choice survives page reloads until the user switches back to "Auto" (which also persists). Picking "Auto" re-evaluates against the current song immediately. In contexts where `localStorage` is unavailable (private mode, sandboxed iframes, some test runners) persistence falls back to the current picker `<option>` value, which still overrides Auto for as long as the page stays loaded.
+- When an Auto-selected renderer fails and core emits `viz:reverted`, the picker falls back to the built-in default and disables auto-switching until the user re-selects Auto.
+- First match wins (picker order), so the registration order of plugins is the tiebreaker. Keep predicates narrow to avoid stealing songs from more specialized viz.
+
+**WebGL viz in Auto mode.** Auto evaluation runs on every `song:ready` regardless of which renderer is active. Auto-installing a WebGL renderer when the canvas is currently 2D — or reverting from a WebGL Auto pick to the default 2D — works without a reload because `setRenderer` swaps the canvas element when `contextType` differs (see "Canvas context-type swapping" above). WebGL viz can therefore safely declare `matchesArrangement` and rely on Auto. For 3D Highway specifically, `_canRun3D()` in app.js still gates Auto from picking it on machines without WebGL2 — that fallback is independent of canvas swapping.
+
+## 2. Overlay contract — for add-on layers
+
+Plugins that add a layer on top of whichever visualization is active — HUDs, fretboard diagrams, chord labels, practice feedback — don't replace the renderer. They manage their own canvas, their own rAF loop, and a toggle button somewhere visible (typically a navbar pill), reading public highway state via the getters:
+
+- `highway.getTime()` / `highway.getBeats()` — current playback position
+- `highway.getNotes()` / `highway.getChords()` — difficulty-filter-aware arrays
+- `highway.getChordTemplates()` — chord shape lookup table; index by `chord.id` from `getChords()` to get `{ name, fingers, frets }`. `fingers` and `frets` are per-string arrays (length matches the tuning's string count); within `fingers`, `-1` = unused, `0` = open string, `n > 0` = finger number. RS XML sources populate real fingerings; GP imports currently emit all `-1` since pre-import sources don't carry finger data. Not filter-aware: templates are static metadata, every `chord_id` referenced by `getChords()` is guaranteed valid.
+- `highway.getSongInfo()` — tuning, arrangement, capo
+- `highway.getStringCount()` — number of strings on the active arrangement (4 for bass, 6 for guitar, 7+ for extended-range GP imports). Derived server-side as `max(notes-max-string + 1, name-based fallback, len(tuning))` where the tuning length only contributes when it isn't the RS-XML padded 6-string form (sloppak / GP-imported sources carry trimmed tuning lengths). The name-based fallback is 4 for arrangements containing "bass" (case-insensitive) and 6 otherwise. This combination handles partial-string-usage charts (a 6-string lead that never plays string 5), extended-range GP imports (5-string bass, 7-string guitar), and sloppaks that explicitly encode the instrument range — without requiring plugins to do their own arrangement-name matching.
+- `highway.getLefty()` / `highway.getInverted()` — mirror + invert state
+
+Overlays do NOT appear in the viz picker and do NOT declare `"type": "visualization"` in `plugin.json`. They coexist with whichever renderer (default 2D, 3D highway, piano, ...) the user has picked.
+
+### Key rules
+
+- **Own your rAF + canvas** — don't piggyback on `_drawHooks` or on `createHighway`'s rendering context. Draw hooks fire for the default 2D renderer and for custom renderers that explicitly call `window.highway.fireDrawHooks(ctx, W, H)` (e.g. the bundled 3D highway fires them on its 2D overlay canvas), but not for every custom renderer.
+- **Re-read state every frame** — overlay output must track whatever the current renderer is drawing. Don't cache note positions across frames.
+- **Respect lefty + invert toggles** — if the overlay depicts strings or frets, mirror using the same transforms the active renderer would.
+- **If you position with `highway.project` / `highway.fretX` (the 2D-highway geometry), gate on `highway.isDefaultRenderer()`** — those helpers describe the *built-in 2D* highway's depth curve and fret zoom. When a custom renderer (3D highway, piano, …) is active your draw hook still fires (on that renderer's 2D overlay layer), but those coordinates won't match its scene — markers land in arbitrary places. Skip rendering when `isDefaultRenderer()` is false; the custom renderer owns that feedback. Renderer-agnostic overlays (fretboard diagram, chord-label HUD — they use `getNotes()`/`getChordTemplates()` + their own layout) don't need this guard.
+- **Clean up on toggle-off** — cancel rAF and remove/hide the overlay canvas so inactive overlays aren't wasting frames.
+
+Reference: [fretboard plugin](https://github.com/byrongamatos/slopsmith-plugin-fretboard) — canonical overlay implementation (navbar toggle, own canvas, 80ms active-note window).
+
+### Why two contracts?
+
+setRenderer plugs into an existing highway — main-player or splitscreen-panel — reusing its WebSocket and data parsing, so the common "I want a different look for the same data" case is zero boilerplate AND multi-instance for free. Overlays compose with whatever renderer is active — they decorate rather than replace, so multiple can stack (fretboard + chord labels + practice feedback) without fighting over the canvas.
+
+A previous standalone-pane contract (`window.createMyVisualization({ container })` with its own WebSocket per pane) was used by splitscreen pre-Wave-C. It's been retired now that splitscreen calls `setRenderer` on per-panel `createHighway()` instances; if you find references in older plugin docs or external integration guides, those describe the legacy path.
+
+## 3. Note-state provider — for scorers that want renderers to "light up" notes (slopsmith#254)
+
+A scoring plugin (note_detect) can publish a per-note judgment so whichever renderer is active draws the **gem itself** lit on a correct hit, and keeps a sustain trail glowing while it's still being played correctly — instead of a separate overlay ring floating near the note.
+
+```js
+// In the plugin (after resolving the highway instance):
+highway.setNoteStateProvider((note, chartTime) => {
+    // `note` is the chart note object ({ t, s, f, sus, ... }); for chord
+    // notes `chartTime` is the chord's time. Return one of:
+    //   - falsy  → no special state (render normally)
+    //   - 'hit'    — struck correctly; renderer lights the gem
+    //   - 'active' — a sustained note is right now being held correctly
+    //   - 'miss'   — missed; renderer may red-wash the gem
+    //   - { state: <one of the above>, alpha?: 0..1, color?: '#rrggbb' }
+    // You own all fade timing: return a decaying `alpha` for a struck-note
+    // glow, `alpha: 1` (or a bare string) for a held sustain, and stop
+    // returning state when the effect should end. Keep it cheap — it's
+    // called per visible note per renderer per frame.
+});
+// On teardown:  highway.setNoteStateProvider(null);
+```
+
+- Only one provider is active at a time (last `setNoteStateProvider` wins). `highway.getNoteStateProvider()` returns the current one (or null).
+- The built-in 2D highway consults it in `drawNote` / `drawSustains` / the chord-frame path: 'hit'/'active' → bright string colour + additive halo + a contained "sizzle" (crackling sparks, throbbing core, a shockwave ring on a fresh strike) on the gem and a bright (vs dim) sustain trail; 'miss' → faint red wash. The bundled **3D highway** reads the same data via `bundle.getNoteState` (bright string-tinted outline + bright body + glowing sustain + a contained sparkle hugging the note rect on hit/active; red outline + suppressed body on miss). Custom renderers that want it call `bundle.getNoteState(note, chartTime)` — it null-guards and returns the normalized `{ state, alpha, color }` (or null).
+- This is orthogonal to the overlay contract: note_detect remains an overlay (HUD, diagnostic miss markers, the "currently detected" indicator) *and* a scorer that feeds this provider. A renderer that ignores `getNoteState` simply doesn't light gems — nothing breaks.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [plugin-manifest.md](plugin-manifest.md) — declaring `"type": "visualization"`
+- [websocket-protocol.md](websocket-protocol.md) — the WebSocket stream that drives `bundle`
+- [plugin-audio-mixer.md](plugin-audio-mixer.md) — companion contract for audio-producing plugins

docs/skills/debugging-keyboard-shortcuts.md

@@ -1,12 +1,12 @@
 # Debugging Keyboard Shortcuts
 
-This skill helps you debug keyboard shortcut issues in FeedBack.
+This skill helps you debug keyboard shortcut issues in Slopsmith.
 
 ## Quick Start
 
-1. **Start FeedBack:**
+1. **Start Slopsmith:**
    ```bash
-   cd ~/path/to/feedBack
+   cd ~/path/to/slopsmith
    LIBRARY_PATH=/path/to/your/library docker compose up -d
    ```
 

docs/sloppak-hand-editing.md

@@ -4,7 +4,7 @@ A `.sloppak` is just a zip of plain files: some YAML, some JSON, some OGG audio,
 
 This guide walks through the most common edits, aimed at musicians who are comfortable with a text editor and Audacity but don't live on the command line.
 
-> For the format **schema** (what every field means, how the wire format works, how to extend the format with new data types), see the authoritative [feedpak spec](https://github.com/got-feedback/feedpak-spec/blob/main/spec/feedpak-v1.md) (the local [sloppak-spec.md](sloppak-spec.md) is now a pointer to it). This document is the **how-do-I-actually-edit-mine** companion.
+> For the format **schema** (what every field means, how the wire format works, how to extend the format with new data types), see [sloppak-spec.md](sloppak-spec.md). This document is the **how-do-I-actually-edit-mine** companion.
 
 ---
 
@@ -17,27 +17,27 @@ A sloppak exists in two interchangeable forms:
 | **Directory** | A folder named `something.sloppak/` with the files loose inside | **Authoring** — easy to edit, no zip/unzip cycle |
 | **Zip** | A `something.sloppak` file (zip with the same files inside) | **Distributing** — single file to share |
 
-FeedBack reads both. You can drop either one straight into your DLC folder and it'll show up in the library.
+Slopsmith reads both. You can drop either one straight into your DLC folder and it'll show up in the library.
 
 ### Unzipping for editing
 
-FeedBack's converter ships sloppaks in zip form. To edit one, unzip it:
+Slopsmith's converter ships sloppaks in zip form. To edit one, unzip it:
 
 - **Windows:** rename `mysong.sloppak` → `mysong.zip`, right-click → Extract All. Then rename the resulting folder back to `mysong.sloppak/` (with the trailing slash / folder form). Or use [7-Zip](https://www.7-zip.org/) and unzip without renaming.
 - **macOS:** rename `.sloppak` → `.zip`, double-click. Or use The Unarchiver.
 - **Linux:** `unzip mysong.sloppak -d mysong.sloppak/`.
 
-Once you have the directory form, you can edit any file inside and FeedBack will pick it up — no re-zipping required for your own use.
+Once you have the directory form, you can edit any file inside and Slopsmith will pick it up — no re-zipping required for your own use.
 
 ### Cache: when changes don't appear
 
-The first time FeedBack opens a zip-form sloppak, it extracts a working copy into its config directory's cache: `${CONFIG_DIR}/sloppak_cache/<safe-id>` (in the standard Docker setup that's inside the `feedBack-config` volume, mounted at `/config` in the container). The `<safe-id>` is the sloppak filename with each path separator (`/` or `\`) replaced by `__` and each space replaced by `_`. So `My-Song.sloppak` stays `My-Song.sloppak`, and `Artist/My Song.sloppak` becomes `Artist__My_Song.sloppak`.
+The first time Slopsmith opens a zip-form sloppak, it extracts a working copy into its config directory's cache: `${CONFIG_DIR}/sloppak_cache/<safe-id>` (in the standard Docker setup that's inside the `slopsmith-config` volume, mounted at `/config` in the container). The `<safe-id>` is the sloppak filename with each path separator (`/` or `\`) replaced by `__` and each space replaced by `_`. So `My-Song.sloppak` stays `My-Song.sloppak`, and `Artist/My Song.sloppak` becomes `Artist__My_Song.sloppak`.
 
-You almost never need to touch this cache directly. If you edit the **original zip** in your DLC folder, FeedBack re-extracts automatically when the zip's modification time or size changes — just save your edits and reload.
+You almost never need to touch this cache directly. If you edit the **original zip** in your DLC folder, Slopsmith re-extracts automatically when the zip's modification time or size changes — just save your edits and reload.
 
-If a change still isn't appearing, the simplest reset is to remove the matching cache folder so FeedBack rebuilds it on the next song load. In a default Docker install that's `docker exec <container> rm -rf /config/sloppak_cache/<safe-id>` (or the equivalent for your setup).
+If a change still isn't appearing, the simplest reset is to remove the matching cache folder so Slopsmith rebuilds it on the next song load. In a default Docker install that's `docker exec <container> rm -rf /config/sloppak_cache/<safe-id>` (or the equivalent for your setup).
 
-If you'd rather skip the cache layer entirely, **drop the directory form straight into your DLC folder** — FeedBack uses it in place and there's nothing to invalidate.
+If you'd rather skip the cache layer entirely, **drop the directory form straight into your DLC folder** — Slopsmith uses it in place and there's nothing to invalidate.
 
 ---
 
@@ -72,7 +72,7 @@ The use case: the converted rhythm guitar sounds muddy (Demucs has a tough time
 1. Copy `rhythm_custom.ogg` into the sloppak's `stems/` folder.
 2. Open `manifest.yaml` in any text editor (Notepad++, VS Code, BBEdit, gedit — all fine; just **don't use Word**).
 3. Find the `stems:` block. Two things matter here:
-   - **Order:** FeedBack's base `<audio>` element always plays the **first** stem listed in `stems[]`, regardless of `default:` flags. So if you want your custom stem to be what the player plays out-of-the-box (and what users without the Stems plugin will hear), put it **first**.
+   - **Order:** Slopsmith's base `<audio>` element always plays the **first** stem listed in `stems[]`, regardless of `default:` flags. So if you want your custom stem to be what the player plays out-of-the-box (and what users without the Stems plugin will hear), put it **first**.
    - **`default:` flags:** consulted by the [Stems plugin](https://github.com/topkoa/slopsmith-plugin-stems) to decide which faders start un-muted. They do **not** affect what the base `<audio>` element plays — that's purely the first-stem rule above.
 
    Example for a Demucs-split sloppak where you re-recorded the rhythm guitar:
@@ -110,14 +110,14 @@ The use case: the converted rhythm guitar sounds muddy (Demucs has a tough time
 
 ### Step 5 — Reload and verify
 
-Reload the song in FeedBack. The [Stems plugin](https://github.com/topkoa/slopsmith-plugin-stems) will show a fader for `rhythm_custom` next to the others. If you don't see it, check the cache notes in §1.
+Reload the song in Slopsmith. The [Stems plugin](https://github.com/topkoa/slopsmith-plugin-stems) will show a fader for `rhythm_custom` next to the others. If you don't see it, check the cache notes in §1.
 
 ### Common gotchas
 
 - **Sample-rate mismatch** → choppy/pitched-wrong playback. Re-export from Audacity at exactly the rate the other stems use.
 - **Mono vs stereo mismatch** is fine for playback but levels can feel different — match what the other stems use if you want consistent behavior in the mixer.
 - **Silence padding at the start** of your recording → your stem will play late. Trim it tight in Audacity before exporting.
-- **Tabs in `manifest.yaml`** → FeedBack will refuse to load the song. Use two spaces.
+- **Tabs in `manifest.yaml`** → Slopsmith will refuse to load the song. Use two spaces.
 
 ---
 
@@ -242,7 +242,7 @@ For 4-string bass, only indices 0–3 are meaningful; leave 4 and 5 at `0`.
 
 ### What *not* to put in `manifest.yaml`
 
-Don't add per-machine settings (audio device picks, MIDI port IDs), UI state, or your own play counts. The sloppak holds the song's authored data — anything that varies by user or machine lives in FeedBack's config dir or the metadata DB. See [feedpak spec §9.5](https://github.com/got-feedback/feedpak-spec/blob/main/spec/feedpak-v1.md#95-what-does-not-belong-in-a-feedpak) for the full list.
+Don't add per-machine settings (audio device picks, MIDI port IDs), UI state, or your own play counts. The sloppak holds the song's authored data — anything that varies by user or machine lives in Slopsmith's config dir or the metadata DB. See [sloppak-spec.md §5.7](sloppak-spec.md#57-dont-break-the-manifest-contract) for the full list.
 
 ---
 
@@ -252,15 +252,15 @@ If you want to share your modified sloppak with someone else, re-zip it:
 
 1. Open the `mysong.sloppak/` directory.
 2. Select **everything inside** — `manifest.yaml`, `arrangements/`, `stems/`, `lyrics.json`, `cover.jpg`.
-3. Zip the **contents**, not the parent folder. (If you zip the folder, the zip will have a top-level `mysong.sloppak/` directory inside, which FeedBack won't parse — the manifest must be at the zip root.)
+3. Zip the **contents**, not the parent folder. (If you zip the folder, the zip will have a top-level `mysong.sloppak/` directory inside, which Slopsmith won't parse — the manifest must be at the zip root.)
 4. Rename `mysong.zip` → `mysong.sloppak`.
 
-For your own use, you can skip this entirely — FeedBack reads the directory form straight from your DLC folder.
+For your own use, you can skip this entirely — Slopsmith reads the directory form straight from your DLC folder.
 
 ---
 
 ## Out of scope (for now)
 
-- **Authoring a sloppak from scratch** (no Guitar Pro / MusicXML source file) — that's a developer task. Start at [feedpak spec §8 (Reading and writing)](https://github.com/got-feedback/feedpak-spec/blob/main/spec/feedpak-v1.md#8-reading-and-writing).
-- **Editing notes / chords in `arrangements/*.json`** — technically possible but extremely tedious by hand: hundreds of objects with short field names per song. The fields are documented in [feedpak spec §6 (Arrangement JSON)](https://github.com/got-feedback/feedpak-spec/blob/main/spec/feedpak-v1.md#6-arrangement-json), but for any real chart edit you want the [Arrangement Editor plugin](https://github.com/got-feedback/feedBack-plugin-editor).
+- **Authoring a sloppak from scratch** (no Guitar Pro / MusicXML source file) — that's a developer task. Start at [sloppak-spec.md §4.2](sloppak-spec.md#42-writing-python-server-side).
+- **Editing notes / chords in `arrangements/*.json`** — technically possible but extremely tedious by hand: hundreds of objects with short field names per song. The fields are documented in [sloppak-spec.md §3](sloppak-spec.md#3-arrangement-json--the-wire-format), but for any real chart edit you want the [Arrangement Editor plugin](https://github.com/got-feedback/feedback-plugin-editor).
 - **Loudness normalization / advanced stem processing** — out of scope here; standard Audacity or ffmpeg workflows apply to any OGG file before you drop it into `stems/`.

docs/sloppak-spec.md

@@ -1,49 +1,939 @@
-# Sloppak / feedpak Format — moved
+# Sloppak Format — Developer Guide
 
-The full format specification that used to live here has moved to its own repository and is now
-the **authoritative, versioned reference**:
+Sloppak is Slopsmith's open, hand-editable song format. This guide is for developers who want to **read**, **write**, or **extend** the format — including adding new data types like drum tabs, vocal pitches, lighting cues, key/scale annotations, or anything else a future visualization plugin might need.
 
-> **📖 https://github.com/got-feedback/feedpak-spec**
-> — normative spec ([`spec/feedpak-v1.md`](https://github.com/got-feedback/feedpak-spec/blob/main/spec/feedpak-v1.md)),
-> JSON Schemas, examples, and a reference validator.
+> If you're a **user** wanting to modify an existing sloppak — record your own rhythm stem, fix metadata, swap cover art, replace a Demucs split — see [sloppak-hand-editing.md](sloppak-hand-editing.md). That guide is the practical, step-by-step companion to this developer reference.
 
-Update bookmarks to point there. This page is a thin pointer kept at the original path so existing
-links keep resolving.
+The authoritative format reference lives in code (`lib/sloppak.py`, `lib/song.py`); this doc explains the why, the how, and the conventions you should follow when adding to it.
 
-## Naming: `sloppak` here, `feedpak` in the spec
+---
 
-The published format is named **feedpak** (extension `.feedpak`, manifest key `feedpak_version`).
-This codebase still uses the legacy **sloppak** name internally — `lib/sloppak.py`, the
-`.sloppak` extension, `FEEDBACK_*` env vars, etc. **They describe the same on-disk format.** The
-rename is repo/public-facing only for now (see the top-level workspace `CLAUDE.md`), so when the
-spec says `feedpak` / `feedpak_version`, the packs this server reads and writes today are the same
-structure under the `.sloppak` name. The internal rename is a separate, later effort.
+## 1. Format at a glance
 
-## Hand-editing a pack
+A sloppak exists in **two interchangeable forms**:
 
-For the practical "how do I edit my own pack" walkthrough (record your own stem, fix metadata,
-swap cover art, replace a stem split), see the companion guide that stays in this repo:
-[sloppak-hand-editing.md](sloppak-hand-editing.md).
+| Form | What it is | Used for |
+|---|---|---|
+| **Directory** | A folder named `*.sloppak/` containing the files below | Authoring, hand editing, plugin development |
+| **Zip archive** | A `.sloppak` file (zip with the same files inside) | Distribution |
 
-## Where the format maps to code (this repo)
+Both forms hold identical contents. Slopsmith resolves either transparently — zip files are unpacked to a cache the first time they're opened (see `resolve_source_dir()` in [lib/sloppak.py](../lib/sloppak.py)).
 
-The spec is implementation-independent; this table is the feedback-specific bridge from format
-concepts to the code that reads and writes them. It is **not** part of the format.
+### Directory layout
+
+```
+my-song.sloppak/
+├── manifest.yaml             # Required — all metadata + file index
+├── arrangements/
+│   ├── lead.json             # One JSON per playable arrangement
+│   ├── rhythm.json
+│   └── bass.json
+├── stems/
+│   ├── full.ogg              # Mixed audio (initial single-stem output; may be absent after stem splitting)
+│   ├── guitar.ogg            # Optional individual stems
+│   ├── bass.ogg
+│   ├── drums.ogg
+│   ├── vocals.ogg
+│   └── other.ogg
+├── lyrics.json               # Optional — syllable-level lyrics
+└── cover.jpg                 # Optional — album art
+```
+
+Three rules to remember:
+
+1. **`manifest.yaml` is the index.** Nothing inside the sloppak is auto-discovered — every file path is listed in the manifest. This makes the format predictable: no scanning, no guessing. (One historical exception: the cover-art handler in `server.py` falls back to `cover.jpg` when `manifest.cover` is missing. New code should not add similar filename fallbacks.)
+2. **Filenames in `manifest.yaml` are POSIX paths**, relative to the sloppak root (forward slashes, no leading `/`).
+3. **YAML for the manifest, JSON for everything else.** YAML is hand-editable for users; JSON is fast-parsed and easy to round-trip in code.
+
+---
+
+## 2. `manifest.yaml` reference
+
+Minimal valid manifest:
+
+```yaml
+title: "Black Hole Sun"
+artist: "Soundgarden"
+duration: 320.5
+arrangements:
+  - id: lead
+    name: Lead
+    file: arrangements/lead.json
+    tuning: [0, 0, 0, 0, 0, 0]
+    capo: 0
+stems:
+  - id: full
+    file: stems/full.ogg
+    default: true
+```
+
+Full set of currently-recognized top-level keys:
+
+| Key | Type | Required | Description |
+|---|---|---|---|
+| `title` | string | yes | Song title |
+| `artist` | string | yes | Artist name |
+| `album` | string | no | Album |
+| `year` | int | no | Release year |
+| `duration` | float | yes | Song length in seconds |
+| `arrangements` | list | yes | Playable arrangements (see §2.1) |
+| `stems` | list | yes | Audio stems (see §2.2) |
+| `stem_separation` | object | no | Structured metadata when stems were produced by an automated separation engine (currently `demucs`). Shape: `{engine, model, version}`. See §2.2 for fields + semver semantics per [slopsmith#357](https://github.com/got-feedback/feedback/issues/357). Omitted for single-stem sloppaks (`stems: [{id: full, ...}]`) and for hand-edited / user-recorded stems |
+| `lyrics` | string | no | Path to lyrics JSON |
+| `lyrics_source` | string | no | Where the lyrics came from: `xml` (vocals XML from the chart source), `whisperx` (auto-transcribed), or `user` (hand-edited). Absent on legacy sloppaks — readers should treat missing as `xml` |
+| `lyric_transcription` | object | no | Structured metadata when lyrics came from an automated engine (currently `whisperx`). Same shape as the parent `stem_separation` block defined by [slopsmith#357](https://github.com/got-feedback/feedback/issues/357) — see §2.3 for fields and semver semantics. Omitted for authored lyrics (`xml`/`user`) |
+| `vocal_pitch` | string | no | Path to per-syllable pitch JSON (`{"version": 1, "notes": [{t, d, midi}, ...]}`). Consumed by [slopsmith-plugin-lyrics-karaoke](https://github.com/got-feedback/feedback-plugin-lyrics-karaoke) to render karaoke note bars. See §2.4 |
+| `pitch_extraction` | object | no | Structured metadata when pitch was extracted by an automated engine (currently `crepe` via the demucs server's `/pitch` endpoint). Same shape as `stem_separation` / `lyric_transcription`. Omitted for hand-edited pitch tracks |
+| `cover` | string | no | Path to cover image |
+| `preview` | string | no | Path to a short preview audio clip (OGG) at the sloppak root. Populated when the source carries a separate short browser-preview clip (decoded to `preview.ogg`); absent otherwise. Consumed by [`slopsmith-plugin-song-preview`](https://github.com/got-feedback/feedback-plugin-song-preview) for hover-to-listen previews in the library |
+| `song_timeline` | string | no | Path to a `song_timeline.json` file carrying song-wide beats and sections (see §5.3). When present, its data takes priority over any beats/sections embedded in arrangement JSONs. Older readers ignore the key and fall back to reading beats/sections from the first arrangement JSON as before |
+| `drum_tab` | string | no | Path to `drum_tab.json` — per-piece drum hits (see §5.3). Implemented end-to-end as of slopsmith#344 |
+
+Unknown keys are **silently ignored** by the loader. This is deliberate — it's the extensibility hook (see §5).
+
+### 2.1. `arrangements[]`
+
+Each entry describes one playable arrangement and points at its JSON file:
+
+```yaml
+arrangements:
+  - id: lead              # filesystem-safe stable ID, used for filenames
+    name: Lead            # display name (Lead/Rhythm/Bass/Combo are sorted first)
+    file: arrangements/lead.json
+    tuning: [0, 0, 0, 0, 0, 0]   # six semitone offsets from E A D G B E
+    capo: 0
+    centOffset: 0.0              # optional float, cents; default 0.0
+```
+
+- `tuning` is a list of semitone offsets from standard `E2 A2 D2 G3 B3 E4`. **Six elements is the standard six-string convention** and the only length `lib/tunings.py` produces friendly names for; 5- and 7-string content is accepted by the loader and falls through to a numeric label. For bass, the four bass strings are at indices 0–3; the other two slots are `0`. Consumers should not hard-code `len(tuning) == 6`.
+- `name` controls the sort order in the UI: `Lead > Combo > Rhythm > Bass > everything else`.
+- `centOffset` is a pitch-shift value in cents. Commonly `-1200.0` for extended-range bass arrangements tuned one octave down; small non-zero values for songs mastered at a non-A440 reference pitch (e.g. A443 ≈ +11.8 cents). Absent / `0.0` means no shift. Exposed to plugins via `getSongInfo().centOffset`.
+- Manifest-level `tuning`, `capo`, and `centOffset` **override** anything embedded in the arrangement JSON. The arrangement JSON's own values are fallbacks.
+- `notation` (optional string) — path to a `notation_<id>.json` file carrying standard musical notation data for this arrangement (see §5.3). When present, the loader surfaces it on `LoadedSloppak.notation_by_id[id]` and the highway WS streams `notation_info` + `notation_measures` messages. The `file:` key may be omitted when `notation:` is present — the loader creates a stub arrangement so the notation file can be the sole data source.
+
+### 2.2. `stems[]`
+
+```yaml
+stems:
+  - id: full
+    file: stems/full.ogg
+    default: true        # plays by default when the song opens
+  - id: guitar
+    file: stems/guitar.ogg
+    default: true
+  - id: drums
+    file: stems/drums.ogg
+    default: false
+```
+
+- `id` is referenced by the Stems plugin and any other consumer; keep it stable.
+- `default` accepts `true`/`false`, or strings (`"on"`/`"off"`/`"true"`/etc.) for hand-edited manifests.
+- A freshly converted sloppak from `lib/sloppak_convert.py` starts with a single `{id: full, file: stems/full.ogg, ...}` entry. After stem-splitting (Demucs), `full.ogg` is removed and the manifest is rewritten with per-instrument entries (`guitar`, `bass`, `drums`, `vocals`, `other`). The format requires only that `stems` is non-empty — there's no specific filename or id that must always be present.
+
+When stems were produced by an automated separation engine (Demucs), an optional `stem_separation` block records which engine + model produced them. Per [slopsmith#357](https://github.com/got-feedback/feedback/issues/357):
+
+```yaml
+stem_separation:
+  engine: demucs           # stable engine id; only `demucs` today
+  model: htdemucs_6s       # specific model name (htdemucs_6s / htdemucs_ft / htdemucs / mdx_extra / ...)
+  version: 1.0.0           # semver for slopsmith's stem-artifact contract
+```
+
+Fields:
+- `engine` — stable identifier for the separation engine. Currently always `demucs`. New engines (e.g. a hypothetical `spleeter`) would get their own stable id.
+- `model` — the engine-specific model id used for this split. For Demucs this is the `-n` flag value.
+- `version` — semver for Slopsmith's stem-artifact contract (independent of upstream Demucs / model versions). Bump per the same semantics #357 defines: patch = metadata-only fixes, minor = backward-compatible additions, major = stem set / packing / post-processing changed and existing splits should be regenerated.
+
+Omitted for single-stem sloppaks (`stems: [{id: full, ...}]` — no automated separation ran) and for hand-edited / user-recorded stems. The RFC reserves a separate `stem_authoring` sibling block for the hand-edit case; that's deferred to a follow-up.
+
+A remote Demucs server can use this block as part of a cache key so that changing the model or major version naturally produces a cache miss. Local plugin jobs should preserve this metadata in job state and in any copied/downloaded manifests.
+
+### 2.3. `lyrics`
+
+If present, points at a JSON file containing a flat list of syllable objects:
+
+```json
+[
+  {"t": 12.34, "d": 0.18, "w": "Hel"},
+  {"t": 12.52, "d": 0.22, "w": "lo-"},
+  {"t": 13.10, "d": 0.30, "w": "world"}
+]
+```
+
+| Field | Meaning |
+|---|---|
+| `t` | Time in seconds |
+| `d` | Duration in seconds |
+| `w` | Syllable text. Trailing `-` joins to the next syllable as one word; trailing `+` marks the last syllable of a line (renderer wraps after it). Both are suffixes on a real syllable — not standalone entries. See `static/highway.js` for the rendering: `raw.endsWith('+')` flags end-of-line, and `sylText` strips the trailing marker before drawing |
+
+When lyrics are present, the optional top-level `lyrics_source` key records where they came from. The assembler sets it to `xml` when the lyrics were parsed from the source chart's vocals XML; the WhisperX auto-transcription fallback (`scripts/transcribe_lyrics.py`, or `--auto-lyrics` on the split scripts) sets it to `whisperx`. Hand-edited lyrics should bump it to `user` so UI consumers can render a different badge (or no badge) than for machine-generated lyrics. The key is absent on sloppaks produced before this field existed — readers should treat missing as `xml` for backward compatibility.
+
+When `lyrics_source` is `whisperx` (or any future automated engine), an optional `lyric_transcription` block records which engine + model produced the file. Shape mirrors the parent `stem_separation` RFC ([slopsmith#357](https://github.com/got-feedback/feedback/issues/357)):
+
+```yaml
+lyric_transcription:
+  engine: whisperx     # stable engine id
+  model: medium        # the WhisperX model size that ran (tiny/base/small/medium/large-v2/large-v3)
+  version: 1.0.0       # semver for slopsmith's lyric-transcription artifact contract
+```
+
+Fields:
+- `engine` — stable identifier for the transcription engine; currently always `whisperx`.
+- `model` — the engine-specific model id used for this transcription.
+- `version` — semver for Slopsmith's lyric-transcription artifact contract (independent of upstream Whisper / WhisperX versions). Bump per the same semantics #357 defines for stems: patch = metadata-only fixes, minor = backward-compatible additions, major = output shape changed and existing transcriptions should be regenerated.
+
+Omitted for authored lyrics (`xml` / `user`). A remote WhisperX server can use this block as part of a cache key the same way #357 envisions for stems — caches should miss whenever any of the three fields change, ensuring stale transcriptions don't get returned after a model bump.
+
+### 2.4. `vocal_pitch`
+
+If present, points at a JSON file holding per-syllable pitch data — the karaoke companion to `lyrics`. Consumed by [slopsmith-plugin-lyrics-karaoke](https://github.com/got-feedback/feedback-plugin-lyrics-karaoke) to render karaoke-style note bars over the lyric text. Shape:
+
+```json
+{
+  "version": 1,
+  "notes": [
+    {"t": 12.34, "d": 0.40, "midi": 64},
+    {"t": 12.78, "d": 0.55, "midi": 67}
+  ]
+}
+```
+
+| Field | Meaning |
+|---|---|
+| `version` | Schema version of this `vocal_pitch.json` file (currently the integer `1`). Bump on a breaking change to the `notes` entry shape. This is *not* the same as the top-level `pitch_extraction.version` block below, which is a semver string used as a cache-key for the extractor engine |
+| `notes` | List of pitch entries, one per syllable that the extractor could lock onto. `t` + `d` mirror the matching `lyrics.json` entry; `midi` is the MIDI note number (60 = middle C). Syllables the extractor couldn't pitch (silent / sub-confidence) are omitted from this list — it may be shorter than `lyrics.json` |
+
+When pitch came from an automated engine (the demucs server's `/pitch` endpoint, which runs CREPE), the optional top-level `pitch_extraction` block records which engine + model produced the file. Same shape and semver-string semantics as `stem_separation` / `lyric_transcription` — distinct from the in-file integer `version` field above:
+
+```yaml
+pitch_extraction:
+  engine: crepe
+  model: v1
+  version: 1.0.0
+```
+
+Omitted for hand-edited pitch tracks. As with the other two automated-artifact blocks, a remote pitch server can use this for cache-key invalidation.
+
+The sloppak assembler runs pitch extraction automatically when `pitch_extraction.enabled` is set in its config AND a server URL is configured (either `pitch_extraction.server_url` or the shared `demucs_server_url`) AND the sloppak has lyrics + a `stems/vocals.ogg` after the split pass — either because `_maybe_transcribe_lyrics` just produced them via WhisperX OR because they were already on disk (from the source chart's vocals XML, hand-authoring, or an earlier build). Pitch is *not* coupled to `whisperx.enabled` — setting `pitch_extraction.enabled=true` alone (with WhisperX off) is enough to retro-generate pitch over any existing on-disk lyrics. Sloppaks built before this field existed simply don't carry it — readers should treat missing `vocal_pitch` as "no pitch data, fall back to whatever the karaoke plugin's local-extraction path produces (if any)".
+
+---
+
+## 3. Arrangement JSON — the wire format
+
+Arrangement JSON files use the **wire format** produced by `arrangement_to_wire()` — the on-disk representation of a complete arrangement. Slopsmith's `/ws/highway/{filename}` endpoint transports similar data as a sequence of typed messages (`notes`, `chords`, `anchors`, `chord_templates`, `phrases`, …) rather than as one identical top-level JSON object. In practice, the WebSocket stream reuses the same per-object field names where applicable, but it should not be treated as a byte-for-byte match for `arrangements/*.json`.
+
+The authoritative serializer/deserializer is in [lib/song.py](../lib/song.py):
+
+- `arrangement_to_wire(arr) → dict` — write
+- `arrangement_from_wire(dict) → Arrangement` — read
+
+### 3.1. Top-level shape
+
+```json
+{
+  "name": "Lead",
+  "tuning": [0, 0, 0, 0, 0, 0],
+  "capo": 0,
+  "centOffset": 0.0,            /* optional, float cents, default 0.0 */
+  "notes":      [ /* see 3.2 */ ],
+  "chords":     [ /* see 3.3 */ ],
+  "anchors":    [ /* see 3.4 */ ],
+  "handshapes": [ /* see 3.5 */ ],
+  "templates":  [ /* see 3.6 */ ],
+  "phrases":    [ /* optional, see 3.7 */ ],
+  "tones":      { /* optional, see 3.9 */ },
+  "beats":      [ /* see 3.8, only on first arrangement */ ],
+  "sections":   [ /* see 3.8, only on first arrangement */ ]
+}
+```
+
+`beats` and `sections` are **song-level** but live on the first arrangement's JSON for legacy reasons — `lib/sloppak.py` hoists them to the `Song` object on load. If you author multiple arrangements, only put them in one file. **New sloppaks should use `song_timeline.json` instead** (see §2 and §5.3) — when the manifest carries a `song_timeline:` key pointing at a schema-valid file, its beats/sections **replace** whatever the arrangement JSONs loaded (the override is applied after arrangement loading, so a valid `song_timeline.json` always wins). Arrangement-JSON beats/sections remain supported for backward compatibility with all existing sloppaks and are the fallback when the file is absent or invalid.
+
+### 3.2. Notes
+
+Field names are short on purpose — these get streamed thousands of times per song. Don't expand them.
+
+```json
+{
+  "t": 12.345,    // time (s)
+  "s": 2,         // string (0 = lowest)
+  "f": 7,         // fret (0 = open, 24 = max)
+  "sus": 0.5,     // sustain (s, 0 = none)
+  "sl": 9,        // pitched slide-to fret (-1 = no slide)
+  "slu": -1,      // unpitched slide-to fret (-1 = no slide)
+  "bn": 1.0,      // bend amount in semitones
+  "ho": false,    // hammer-on
+  "po": false,    // pull-off
+  "hm": false,    // natural harmonic
+  "hp": false,    // pinch harmonic
+  "pm": false,    // palm mute
+  "mt": false,    // string mute
+  "vb": false,    // vibrato
+  "tr": false,    // tremolo
+  "ac": false,    // accent
+  "tp": false,    // tap
+  "ln": false,    // link-next (chord linking metadata; renderers may ignore — runtime linking is derived from proximity)
+  "fhm": false,   // fret-hand mute
+  "plk": false,   // pluck (pop, bass)
+  "slp": false,   // slap (bass)
+  "rh": -1,       // right-hand fingering (-1 = unset)
+  "pkd": -1,      // pick direction (-1 = unset, 0 = down, 1 = up)
+  "ig": false     // ignore (chart-author flag — note is rendered but not scored / sequenced)
+}
+```
+
+Default values: numbers → `0` or `-1` (slides / `rh` / `pkd`), bools → `false`. Omit fields equal to their default if you're authoring by hand — the parser fills them in. **Encoders should default-omit the newer technique keys** (`ln`, `fhm`, `plk`, `slp`, `rh`, `pkd`, `ig`) — the highway streams notes thousands of times per song, so trimming the common case keeps the WebSocket payload tight. The pre-existing keys are still emitted unconditionally to preserve the legacy wire contract.
+
+### 3.3. Chords
+
+A chord groups note-shaped objects under a single time:
+
+```json
+{
+  "t": 30.0,
+  "id": 12,           // index into templates[]
+  "hd": false,        // high-density flag
+  "notes": [
+    {"s": 0, "f": 3, "sus": 0.0, ...},
+    {"s": 1, "f": 5, "sus": 0.0, ...}
+  ]
+}
+```
+
+Chord notes use the same field set as standalone notes, **except `t` is omitted** (the chord carries the time). The fingering / shape lookup is `chord.id → templates[id]`.
+
+### 3.4. Anchors
+
+Where the fretting hand sits. Drives the highway zoom box.
+
+```json
+{"time": 12.0, "fret": 5, "width": 4}
+```
+
+### 3.5. Hand shapes
+
+Spans during which a chord shape is held:
+
+```json
+{"chord_id": 12, "start_time": 30.0, "end_time": 31.5, "arp": false}
+```
+
+- `chord_id` (`int`, default `0`) — index into `templates[]`; identifies which chord template the span is holding.
+- `start_time` (`float`, default `0.0`) — start of the span in seconds.
+- `end_time` (`float`, default `0.0`) — end of the span in seconds.
+- `arp` (`bool`, default `false`, allowed values `true`/`false`) — whether this hand shape should be treated as an arpeggio span rather than a fully-strummed chord hold.
+
+### 3.6. Chord templates
+
+Named shapes referenced by `chord.id` and `handshape.chord_id`:
+
+```json
+{
+  "name": "Em7",
+  "displayName": "Em7",
+  "arp": false,
+  "fingers": [-1,  2,  1, -1, -1, -1],
+  "frets":   [ 0,  2,  2,  0,  0,  0]
+}
+```
+
+- `name` (`string`, default `""`) — canonical template name used by the parser / authoring data.
+- `displayName` (`string`, default `name`) — label shown in the UI; source XML may use this for display-specific variants such as `-arp`.
+- `arp` (`bool`, default `false`, allowed values `true`/`false`) — whether the template is flagged as arpeggiated. Parsed from explicit XML attributes (`arpeggio` / `arp`, any common casing) or inferred from `displayName` markers such as `-arp`.
+- `fingers` (`int[6]`, default `[-1, -1, -1, -1, -1, -1]`) — fretting-hand finger numbers, lowest string first. `-1` = unused string, `0` = open string / no fretting finger, `1..4` = index/middle/ring/pinky.
+- `frets` (`int[6]`, default `[-1, -1, -1, -1, -1, -1]`) — fret numbers, lowest string first. `-1` = unused string, `0` = open string, positive values = fretted note.
+
+### 3.7. Phrases (optional, multi-difficulty data)
+
+Sources that carry per-phrase difficulty ladders (phrase-aware arrangement XML) include this. GP imports and legacy sloppaks omit it:
+
+```json
+"phrases": [
+  {
+    "start_time": 0.0,
+    "end_time":   12.5,
+    "max_difficulty": 4,
+    "levels": [
+      { "difficulty": 0, "notes": [...], "chords": [...], "anchors": [...], "handshapes": [...] },
+      { "difficulty": 1, "notes": [...], "chords": [...], "anchors": [...], "handshapes": [...] },
+      ...
+    ]
+  }
+]
+```
+
+If you're writing a converter that doesn't have multi-difficulty data, **omit the `phrases` key entirely** (don't emit `"phrases": []`). A missing key signals "no ladder, disable the master-difficulty slider"; an empty list is the same in current code but reads ambiguously.
+
+### 3.8. Beats and sections
+
+```json
+"beats":    [{"time": 0.5, "measure": 1}, {"time": 1.0, "measure": -1}, ...],
+"sections": [{"name": "verse", "number": 1, "time": 12.5}, ...]
+```
+
+`measure: -1` = sub-beat (not a downbeat). Section `name` follows the usual song-structure conventions (`intro`, `verse`, `chorus`, `bridge`, `solo`, `outro`, …).
+
+### 3.9. Tones (optional)
+
+`tones` carries the arrangement's guitar tones — the amp/pedal/cabinet gear and the in-song tone switches. It's populated when the source chart carries tone data (`lib/tones.py`); a sloppak authored from scratch may omit it entirely.
+
+```json
+"tones": {
+  "base": "Clean Rhythm",
+  "changes": [
+    {"t": 12.5, "name": "Lead Drive"},
+    {"t": 48.0, "name": "Clean Rhythm"}
+  ],
+  "definitions": [
+    {
+      "Name": "Clean Rhythm",
+      "Key": "Tone_A",
+      "GearList": { /* raw gear blocks: Amp, PrePedal1-4, … */ }
+    }
+  ]
+}
+```
+
+- `base` (string) — the tone in effect before the first change.
+- `changes` (list, time-sorted) — `{"t": seconds, "name": str}` tone switches. The highway draws a marker at each. Omit when the arrangement never switches tone.
+- `definitions` (list) — the **raw tone objects** (`Name`, `Key`, `GearList`), copied verbatim from the source chart's tone manifest. The Tones plugin parses these into the rendered signal chain (it owns the gear-name/image map, so the data is stored unparsed here).
+
+All three sub-keys are individually optional; an arrangement with none of them simply omits `tones`. Readers that don't know about tones ignore the key (the loader preserves it verbatim).
+
+---
+
+## 4. Reading and writing sloppaks programmatically
+
+### 4.1. Reading (Python, server-side)
+
+```python
+from pathlib import Path
+from sloppak import load_song, load_manifest
+
+# Quick metadata only (parses manifest, skips arrangement JSONs)
+manifest = load_manifest(Path("song.sloppak"))
+
+# Full song load (manifest + all arrangements + lyrics)
+loaded = load_song("song.sloppak", dlc_root=Path("/dlc"), unpack_cache_root=Path("/cache"))
+print(loaded.song.title, len(loaded.song.arrangements))
+print(loaded.stems)        # [{"id": "full", "file": "stems/full.ogg", "default": True}]
+print(loaded.manifest)     # raw dict — read your custom keys here
+```
+
+### 4.2. Writing (Python, server-side)
+
+There's no general-purpose writer in `lib/` yet. The current writer lives in [lib/sloppak_convert.py](../lib/sloppak_convert.py) inside the sloppak assembly function — it's the single source of truth for "how a sloppak gets built." If you need to write sloppaks from a new source, copy the structure of that function:
+
+1. Build a `work_dir/` in temp.
+2. Write `arrangements/{id}.json` per arrangement using `arrangement_to_wire()`.
+3. Encode audio to OGG into `stems/`.
+4. Optionally write `lyrics.json`, `cover.jpg`.
+5. Compose the `manifest` dict and dump as YAML with `yaml.safe_dump(manifest, sort_keys=False, allow_unicode=True)`.
+6. Either `shutil.copytree(work_dir, out)` for directory form, or `_zip_dir(work_dir, out)` for zip form.
+
+Always use `yaml.safe_dump` (not `yaml.dump`) and pass `sort_keys=False` so the human-readable order is preserved.
+
+### 4.3. Reading (JavaScript, plugin-side)
+
+Plugins typically don't read the sloppak file directly — they consume the `/ws/highway/{filename}` WebSocket stream (see [`websocket-protocol.md`](websocket-protocol.md) for the message protocol), which produces the same shapes. If you specifically need raw manifest access from the browser, expose it through a custom backend route in your plugin's `routes.py` and fetch it.
+
+---
+
+## 5. Extending the format — adding new data
+
+Sloppak is designed to be extended without breaking older readers. The conventions below come from how `lyrics`, `stems`, and the optional `phrases` ladder were each added.
+
+### 5.1. The golden rule: **manifest opt-in, file off to the side**
+
+New data types should follow this pattern:
+
+1. **Drop a new file** alongside the standard ones (e.g., `drums.json`, `keys.json`, `lighting.json`).
+2. **Add a manifest key** that *points at* that file (e.g., `drum_tab: drums.json`).
+3. **Make consumers gate on the manifest key**: if the key is absent, do nothing. Never auto-discover by filename — that breaks the "manifest is the index" rule.
+
+So a sloppak with drum tabs would look like:
+
+```yaml
+# manifest.yaml
+title: "Song"
+artist: "Band"
+duration: 240.0
+arrangements: [...]
+stems: [...]
+drum_tab: drum_tab.json     # ← new key
+```
+
+```
+my-song.sloppak/
+├── manifest.yaml
+├── arrangements/...
+├── stems/...
+└── drum_tab.json           # ← new file
+```
+
+Older Slopsmith readers ignore the unknown `drum_tab` key (the loader uses `manifest.get("drum_tab")` / unknown keys pass through). Your plugin checks for it and renders accordingly. **Zero coordination needed with core.**
+
+### 5.2. Naming conventions for new keys and files
+
+- **Manifest keys**: `snake_case`, descriptive, singular when the value is one thing (`lyrics`, `cover`, `drum_tab`), plural when it's a list (`stems`, `arrangements`).
+- **File names**: lowercase, hyphenated or underscored, JSON for structured data, OGG for audio, JPG/PNG for images.
+- **Inside JSON**: short field names for hot-path data that gets streamed thousands of times (`t`, `s`, `f` — see §3.2). Long names are fine for one-off metadata.
+- **Time fields**: always `t` or `time` (not `start`, not `timestamp`) — and always **seconds as floats**, not ms or ticks. Be consistent with the existing wire format.
+- **Indexes / IDs**: stable, filesystem-safe, lowercase. Don't reuse a source format's internal numeric IDs unless you have to.
+
+### 5.3. Worked examples for the kinds of additions you mentioned
+
+#### Drum tab
+
+`drum_tab.json` carries per-piece hits authored on top of the song's audio.
+Implemented end-to-end as of slopsmith#344 (drums-from-scratch): the loader
+in `lib/sloppak.py` parses it, `lib/drums.py` defines the canonical piece-id
+vocabulary, and `/ws/highway/{filename}` streams it as `drum_tab` + chunked
+`drum_hits` messages.
+
+```json
+{
+  "version": 1,
+  "name": "Drums",
+  "kit": [
+    {"id": "kick",      "name": "Kick"},
+    {"id": "snare",     "name": "Snare"},
+    {"id": "hh_closed", "name": "Hi-hat (closed)"},
+    {"id": "hh_open",   "name": "Hi-hat (open)"},
+    {"id": "crash_r",   "name": "Crash (right)"},
+    {"id": "ride",      "name": "Ride"}
+  ],
+  "hits": [
+    {"t": 0.500, "p": "kick",      "v": 110},
+    {"t": 0.750, "p": "snare",     "v":  92},
+    {"t": 0.750, "p": "hh_closed", "v":  70},
+    {"t": 1.000, "p": "snare",     "v":  60, "g": true},
+    {"t": 1.250, "p": "snare",     "v": 105, "f": true},
+    {"t": 4.000, "p": "crash_r",   "v": 120, "k": 0.080}
+  ]
+}
+```
+
+Manifest:
+
+```yaml
+drum_tab: drum_tab.json
+```
+
+##### Hit fields
+
+| key | type | meaning |
+| --- | --- | --- |
+| `t` | float seconds | hit time, required, monotonic in `hits[]` |
+| `p` | string | piece-id from the closed list below; required |
+| `v` | int 1-127 | velocity (default 100) |
+| `g` | bool | ghost note (renders smaller / outline-only) |
+| `f` | bool | flam (renders a small leading ghost glyph 30 ms early) |
+| `k` | float seconds | cymbal-choke tail duration (renders a fade-out) |
+
+##### Canonical piece-id vocabulary
+
+A closed list lives in `lib/drums.py::PIECES`. Open/closed hi-hat are
+**distinct piece-ids**, not articulation flags — hit detection must reject
+a closed-hat strike on an open-hat note, which it can only do if the
+articulation is part of the piece-id.
+
+| piece-id | category | default GM MIDI | default shape |
+| --- | --- | --- | --- |
+| `kick` | kick | 35, 36 | bar (full-width across all non-kick lanes) |
+| `snare` | drum | 38, 40 | rectangle |
+| `snare_xstick` | drum | 37 | hatched rectangle |
+| `tom_hi` | drum | 50, 48 | rectangle |
+| `tom_mid` | drum | 47, 45 | rectangle |
+| `tom_low` | drum | 43 | rectangle |
+| `tom_floor` | drum | 41 | rectangle |
+| `hh_closed` | cymbal | 42 | filled circle |
+| `hh_open` | cymbal | 46 | ring (outline) circle |
+| `hh_pedal` | cymbal | 44 | small circle with × |
+| `stack` | cymbal | 30 | jagged circle (no GM standard — reuses 30 from extended-percussion range) |
+| `crash_l` | cymbal | 49 | circle |
+| `crash_r` | cymbal | 57 | circle |
+| `splash` | cymbal | 55 | small circle |
+| `china` | cymbal | 52 | jagged circle |
+| `ride` | cymbal | 51, 59 | circle |
+| `ride_bell` | cymbal | 53 | circle with centre dot |
+| `bell` | cymbal | 80 | circle with centre dot (no GM standard — reuses "Mute Triangle") |
+
+Unknown piece-ids round-trip through the loader (forward-compat); the
+client just renders them as a default rectangle.
+
+##### Wire format
+
+Streamed as two highway-WS message types:
+
+```json
+{ "type": "drum_tab", "version": 1, "name": "Drums",
+  "kit": [{"id": "kick", "name": "Kick"}, ...], "total": 1234 }
+```
+
+…followed by one or more chunks of 500 hits:
+
+```json
+{ "type": "drum_hits", "data": [{"t": 0.5, "p": "kick", "v": 110}, ...],
+  "total": 1234 }
+```
+
+##### Design notes
+
+- `kit[]` is the legend — fixed metadata, separated from hot-path data.
+- `hits[]` uses short field names because this list can be thousands long.
+- `v` defaults to 100; ghost / flam / choke flags are all optional.
+- Older sloppaks whose drums are encoded as guitar notes (`midi = string*24 + fret`) still play — the drums plugin keeps a legacy decoder that reads the standard `notes` stream and synthesises `drum_hits` from it.
+
+#### Song timeline (beats and sections as a top-level file)
+
+`song_timeline.json` moves song-wide beats and sections out of the first
+arrangement JSON and into a dedicated file. Implemented in `lib/sloppak.py`
+alongside the notation format: the loader reads the manifest's optional
+`song_timeline:` key, validates the file, and populates `Song.beats` /
+`Song.sections` from it, taking priority over any beats/sections embedded
+in arrangement JSONs.
+
+```json
+{
+  "version": 1,
+  "beats": [
+    {"time": 0.500, "measure": 1},
+    {"time": 1.000, "measure": -1},
+    {"time": 1.500, "measure": -1},
+    {"time": 2.000, "measure": 2}
+  ],
+  "sections": [
+    {"name": "intro",  "number": 1, "time": 0.0},
+    {"name": "verse",  "number": 1, "time": 16.0},
+    {"name": "chorus", "number": 1, "time": 32.0}
+  ]
+}
+```
+
+Manifest:
+
+```yaml
+song_timeline: song_timeline.json
+```
+
+| Field in `beats[]` | Type | Notes |
+|---|---|---|
+| `time` | float seconds | Beat timestamp. Matches the existing arrangement-JSON wire convention |
+| `measure` | int | 1-based downbeat number. `-1` = sub-beat (not a downbeat) |
+
+| Field in `sections[]` | Type | Notes |
+|---|---|---|
+| `name` | string | song-structure convention: `intro`, `verse`, `chorus`, `bridge`, `solo`, `outro`, … |
+| `number` | int | Section repeat number |
+| `time` | float seconds | Section start |
+
+**Backward compatibility.** Sloppaks without `song_timeline:` continue to
+work — the loader falls through to reading beats/sections from the first
+arrangement JSON exactly as before. No migration is needed.
+
+**New sloppaks** should put beats/sections here and leave arrangement JSONs
+free of timeline data. This is especially important for notation-only
+arrangements (see below) where there may be no arrangement JSON at all.
+
+---
+
+#### Notation format (standard musical notation per arrangement)
+
+The notation format promotes keys, piano, violin, and any other
+staff-notation instrument to first-class status with their own data
+structure, separate from the guitar wire format. Implemented in
+`lib/sloppak.py` and `lib/notation.py`; the highway WS streams
+`notation_info` + `notation_measures` messages when notation data is
+present for the active arrangement.
+
+**Architecture: per-arrangement, not song-wide.** Unlike `drum_tab`
+(one drum track per song, top-level manifest key), notation is
+per-instrument. A song could carry both `notation_keys.json` and
+`notation_violin.json`. The manifest key lives on the **arrangement
+entry**, not at the top level.
+
+```yaml
+arrangements:
+  - id: keys
+    name: Keys
+    type: piano
+    notation: notation_keys.json   # per-arrangement sub-key
+    # file: is optional when notation: is present
+```
+
+```text
+my-song.sloppak/
+├── manifest.yaml
+├── song_timeline.json
+├── notation_keys.json
+└── stems/
+    └── full.ogg
+```
+
+**`notation_<id>.json` — file schema:**
+
+```json
+{
+  "version": 1,
+  "instrument": "piano",
+  "staves": [
+    {"id": "rh", "clef": "G2", "label": "Right Hand"},
+    {"id": "lh", "clef": "F4", "label": "Left Hand"}
+  ],
+  "measures": [
+    {
+      "idx": 1,
+      "t": 0.0,
+      "ts": [4, 4],
+      "ks": 0,
+      "tempo": 120.0,
+      "staves": {
+        "rh": {
+          "voices": [{"v": 1, "beats": [
+            {"t": 0.000, "dur": 4, "notes": [{"midi": 64}]},
+            {"t": 0.500, "dur": 4, "notes": [{"midi": 67}]}
+          ]}]
+        },
+        "lh": {
+          "voices": [{"v": 1, "beats": [
+            {"t": 0.000, "dur": 1, "notes": [{"midi": 52}, {"midi": 60}]}
+          ]}]
+        }
+      }
+    }
+  ]
+}
+```
+
+**Top-level fields:**
+
+| Field | Type | Notes |
+|---|---|---|
+| `version` | int | Always `1`. Bump on breaking schema change |
+| `instrument` | string | Mirrors arrangement `type`: `piano`, `violin`, `guitar`, etc. Makes the file self-describing |
+| `rights` | string | Optional copyright / rights text (MusicXML `<rights>`). Omit when absent |
+| `lyricist` | string | Optional lyricist credit (MusicXML `<creator type="lyricist">`). Omit when absent |
+| `arranger` | string | Optional arranger credit (MusicXML `<creator type="arranger">`). Omit when absent |
+| `staves` | list | Static staff definitions. Each has `id` (stable, referenced by `measures[].staves` keys), `clef` (see below), and optional `label` |
+| `measures` | list | Ordered measure data — the hot path |
+
+**Clef vocabulary** (defined in `lib/notation.py::CLEFS`):
+
+| Value | Meaning |
+|---|---|
+| `G2` | Treble clef — guitar, violin, flute, piano RH |
+| `F4` | Bass clef — bass guitar, cello, piano LH |
+| `C3` | Alto clef — viola |
+| `C4` | Tenor clef — cello upper register, trombone |
+| `neutral` | Unpitched / percussion staff |
+
+**Measure fields:**
+
+| Field | Type | Notes |
+|---|---|---|
+| `idx` | int | 1-based measure number |
+| `t` | float | Time in seconds at measure downbeat |
+| `ts` | int[2] | Time signature `[numerator, denominator]`. Omit if unchanged |
+| `beat_groups` | int[] | Beat grouping for compound and irregular meters, as a list of integers. Each integer is the count of time-signature denominator units in that primary beat group. The sum must equal the time-signature numerator. E.g. 6/8 → `[3, 3]`; 9/8 → `[3, 3, 3]`; 7/8 → `[2, 2, 3]`; 5/8 → `[2, 3]` or `[3, 2]`. Omit for simple meters (2/4, 3/4, 4/4) where grouping is unambiguous. Renderers translate this to their own beam-grouping API at render time — this field is renderer-agnostic. |
+| `ks` | int | Key signature: semitones from C, −7 to +7 (negative = flats, positive = sharps). Omit if unchanged |
+| `tempo` | float | BPM. Omit if unchanged |
+| `pickup` | bool | `true` when this measure is an anacrusis (pickup / upbeat) shorter than the time signature implies (MusicXML `implicit="yes"`). Renderers suppress the measure number and start counting from the next full measure. Omit when false |
+| `staves` | object | Keyed by staff `id`. Each staff has optional `clef` (omit if unchanged) and `voices` |
+
+**Beat fields** (inside `staves → voices → beats`):
+
+| Field | Default | Notes |
+|---|---|---|
+| `t` | required | Time in seconds |
+| `dur` | required | Duration denominator: `1`=whole, `2`=half, `4`=quarter, `8`=eighth, `16`=sixteenth, `32`=thirty-second |
+| `dot` | omit | Augmentation dots: `1`=dotted, `2`=double-dotted |
+| `rest` | omit | `true` if this beat is a rest; `notes` is omitted |
+| `tu` | omit | Tuplet: `[numerator, denominator]`, e.g. `[3, 2]` for triplet |
+| `beat_pos` | omit | Exact position within the measure as a rational `[numerator, denominator]` pair, where the denominator is the time-signature denominator. E.g. beat 2 in 6/8 (the second dotted quarter) = `[3, 8]`. Avoids floating-point imprecision when deriving beat position from tempo and absolute time. Omit if not set by the importer. Renderers that do not recognise this field derive position from `t` and the tempo map as before. |
+| `notes` | omit | List of note objects (omit for rests) |
+| `dyn` | omit | Dynamic: `ppp`, `pp`, `p`, `mp`, `mf`, `f`, `ff`, `fff` |
+| `slr` | omit | Slur start |
+| `slre` | omit | Slur end |
+| `grace` | omit | Grace-note beat, typed: `"a"` = acciaccatura (slashed, steals time from the previous note; MusicXML `<grace slash="yes">`), `"p"` = appoggiatura (unslashed, steals time from the following note; `<grace>`). The beat's `dur` is the grace note's written duration. Vocabulary in `lib/notation.py::GRACE_TYPES` |
+| `arp` | omit | `true` when the beat's chord is arpeggiated (rolled; MusicXML `<arpeggiate>`) |
+| `ferm` | omit | `true` when the beat carries a fermata (MusicXML `<fermata>`) |
+| `spd` / `sph` / `spu` | omit | Sustain pedal: pedal **d**own / **h**old-through-this-beat / **u**p. This is the only pedal encoding — there is deliberately no separate `ped` field. MusicXML mapping: `<pedal type="start">` → `spd`, `<pedal type="change">` → `spu` + `spd` on the same beat (re-pedal), `<pedal type="stop">` → `spu`; beats inside an active pedal span carry `sph` |
+| Additional beat effects | omit | `cre`, `dec`, `vib`, `vibw`, `fade`, `pm`, `lr`, `slap`, `pop`, `tap`, `su`, `sd`, `rasg`, `golpe`, `wah`, `txt`, `chrd` — all optional, omit when absent |
+
+**Note fields** (inside `beats → notes`):
+
+| Field | Default | Notes |
+|---|---|---|
+| `midi` | required | MIDI pitch 0–127. Unambiguous — no string/fret/tuning indirection |
+| `tied` | omit | Tied from the previous beat |
+| `acc` | omit | Accidental override: `null`/omit = derive from key sig; `0` = force natural (♮); `−2`/`−1`/`1`/`2` = double-flat/flat/sharp/double-sharp |
+| `stem` | omit | Force stem direction: `"up"` or `"down"` (MusicXML `<stem>`). Omit to let the renderer decide. Vocabulary in `lib/notation.py::STEM_DIRECTIONS` |
+| Additional note effects | omit | `stc`, `ten`, `ac`, `hac`, `vib`, `vibw`, `dead`, `ghost`, `fng`, `rfng`, `str`, `harm`, `bend`, `slide`, `trill`, `ho`, `po`, `tp`, `barre` — all optional |
+
+**Wire format.** `song_info` carries `has_notation: bool`. Notation data
+is streamed as two highway-WS message types after `sections`, before `anchors`:
+
+```json
+{"type": "notation_info", "version": 1, "instrument": "piano",
+ "staves": [...], "total": 64}
+```
+
+…followed by one or more chunks of 32 measures:
+
+```json
+{"type": "notation_measures", "data": [...], "total": 64}
+```
+
+`total` is the measure count across **all** chunks. Clients accumulate `data` arrays until the accumulated measure count reaches `total` (an individual chunk's `data.length` says nothing — every full chunk of a multi-chunk stream is shorter than `total`). The `anchors` frame that follows the notation block is a secondary end-of-block signal.
+
+**`lib/notation.py`** is the vocabulary library: `SCHEMA_VERSION`, `CLEFS`, `DURATIONS`, `validate_notation()`, `measure_to_wire()`, `measures_to_wire()`.
+
+**Legacy fallback.** Sloppaks that carry keys as guitar wire format (Clone Hero converted content) continue to work — the notation plugin checks for the `notation` key on the arrangement entry. When absent, it falls back to decoding guitar wire format notes via `midi = s * 24 + f`.
+
+**v1 non-features (accepted limitations).** The following are deliberately
+out of schema v1; they ship, if ever, as **additive v1.x patches** (new
+optional fields old consumers ignore — the permissive validator passes
+unknown fields through by design):
+
+- Microtonal pitch (anything finer than the ±2 semitone `acc` vocabulary).
+- Figured bass.
+- Mid-measure key-signature, time-signature, or clef changes (all three are
+  measure-granular in v1).
+- Ottava lines (`ott`), repeat/volta barline semantics (`barline`),
+  ornaments beyond trills (mordents, turns), tremolo (`trem`), and notated
+  glissando lines (`glis`).
+
+Importers MUST drop these source features with a logged warning rather than
+approximate them into wrong notation; renderers MUST NOT invent semantics
+for field names from this list before a v1.x patch specifies them.
+
+---
+
+#### Key / scale annotations (for theory-aware visualizations)
+
+`keys.json` mirroring the `sections[]` shape:
+
+```json
+{
+  "version": 1,
+  "events": [
+    {"t":   0.0, "key": "Em",     "scale": "natural_minor"},
+    {"t":  64.5, "key": "G",      "scale": "major"},
+    {"t": 142.0, "key": "Em",     "scale": "natural_minor"}
+  ]
+}
+```
+
+Manifest:
+
+```yaml
+keys: keys.json
+```
+
+Each entry implicitly applies until the next event. Same model as `sections[]`.
+
+#### Vocal pitch contour (a different shape, a different key)
+
+The canonical `vocal_pitch` key + file (defined in §2.4) is the
+per-syllable note format consumed by the karaoke plugin —
+`{version: 1, notes: [{t, d, midi}]}`. If you want to ship a finer-
+grained pitch *contour* (one sample every 20 ms, Hz instead of MIDI),
+that's a different shape and should ride on its own manifest key so
+the two don't collide:
+
+```yaml
+vocal_pitch_contour: vocal_pitch_contour.json
+```
+
+```json
+{
+  "version": 1,
+  "samples": [
+    {"t": 0.000, "hz": 220.5},
+    {"t": 0.020, "hz": 222.1}
+  ]
+}
+```
+
+Per §5.1, manifest keys are cheap — reach for a new one when the
+schema diverges, don't overload an existing key with a second shape.
+
+### 5.4. `version` field — always include it
+
+Every new file should have `"version": 1` at the top. It's free insurance: when you change the schema later, `version: 2` consumers can branch on it. Old consumers without that branch ignore the file (or fall back gracefully).
+
+### 5.5. Stay backward-compatible
+
+If you change a field that already shipped:
+
+- **Adding fields** is always safe (older readers ignore them).
+- **Removing fields** breaks older readers. Don't.
+- **Repurposing fields** (changing meaning or units) is the worst — bump `version` and branch.
+
+If you're tempted to remove or repurpose: leave the old field, add a new one, and sunset the old one over a release or two.
+
+### 5.6. When to put data inside an arrangement vs. its own file
+
+- **Inside arrangement JSON** (`arrangements/lead.json`):
+  - Data that is *per-arrangement* and *per-instrument* (notes, chords, anchors, hand-shapes — guitar specifics).
+  - Data that meaningfully differs between Lead and Rhythm versions of the same song.
+- **Its own file** (and pointed-at via manifest key):
+  - Data that is *song-wide* (lyrics, beats, sections, tempo map, drum tab, lighting, key/scale changes).
+  - Data that may be authored or generated independently of the playable arrangement (a stem split, an AI-generated drum tab).
+
+Beats and sections historically lived inside the first arrangement JSON (early arrangement XML put them there). The `song_timeline.json` file (see §5.3) is the correct home for new sloppaks — the loader reads it first and it takes priority. New song-wide data should always be its own file.
+
+### 5.7. Don't break the manifest contract
+
+A few things that should *not* end up in `manifest.yaml`:
+
+- **Per-machine settings** (DMX universes, IPs, output device picks) — those go in `${CONFIG_DIR}/...json`, not the sloppak.
+- **UI state** (last zoom level, panel sizes) — `localStorage` only.
+- **User progress / play counts** — Slopsmith stores these in its metadata DB, not in the sloppak.
+
+The sloppak holds **the song's authored data**. Anything that varies by user or by machine is out.
+
+---
+
+## 6. Quick reference — file types you'll touch
+
+| File | Format | Schema lives in | Authority |
+|---|---|---|---|
+| `manifest.yaml` | YAML | `lib/sloppak.py` (`load_manifest`, `extract_meta`) | This doc + the loader |
+| `arrangements/*.json` | JSON | `lib/song.py` (`arrangement_to_wire`, `arrangement_from_wire`) | The wire-format functions |
+| `lyrics.json` | JSON (flat list) | `lib/sloppak.py` (passed through to `Song.lyrics`) | This doc §2.3 |
+| `song_timeline.json` | JSON | `lib/sloppak.py` (loader) | This doc §5.3 |
+| `notation_<id>.json` | JSON | `lib/notation.py` (`validate_notation`, `measures_to_wire`) | This doc §5.3 |
+| `stems/*.ogg` | OGG Vorbis | — | Convention: `q:a 5` for size/quality balance |
+| `cover.jpg` | JPEG | — | Convention: square, 500–1500 px on a side |
+| Your new file | JSON (preferred) | Your plugin's spec doc | You |
+
+---
+
+## 7. Testing your extension
+
+If you add a new file type or manifest key:
+
+1. **Round-trip test**: write a sample, load it, write it back, compare. Add to `tests/test_sloppak.py`.
+2. **Backward-compat test**: load a sloppak that *doesn't* have your new key — your code must not crash, and the song must still play.
+3. **Hand-edit test**: open the directory form in a text editor, change a field by hand, reload Slopsmith. The format is meant to be hand-editable; your additions should preserve that.
+4. **Both forms**: test with both the directory form and the zipped form. The unpack cache is invalidated based on mtime and size, so you can repackage and reload without restarting the server.
+
+The full pytest suite (`pytest`) must stay green before any PR.
+
+---
+
+## 8. Where to look in the code
 
 | For… | Read |
 |---|---|
 | Format detection, source resolution, zip unpacking | [lib/sloppak.py](../lib/sloppak.py) |
 | Data classes (`Note`, `Chord`, `Arrangement`, `Song`, `Phrase`) | [lib/song.py](../lib/song.py) |
 | Wire-format helpers (`*_to_wire` / `*_from_wire`) | [lib/song.py](../lib/song.py) |
-| The reference pack writer (assembly pipeline) | [lib/sloppak_convert.py](../lib/sloppak_convert.py) |
-| Drum-tab vocabulary and wire helpers | [lib/drums.py](../lib/drums.py) |
+| The reference sloppak writer | [lib/sloppak_convert.py](../lib/sloppak_convert.py) |
+| Drum tab vocabulary and wire helpers | [lib/drums.py](../lib/drums.py) |
 | Notation vocabulary and wire helpers | [lib/notation.py](../lib/notation.py) |
 | Live streaming over WebSocket (consumes the same shapes) | `server.py` (`/ws/highway/{filename}`) |
-| The plugin system (where new visualization consumers go) | [CLAUDE.md](../CLAUDE.md) |
+| The plugin system (where new viz consumers go) | [docs/PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) + [docs/plugin-visualization-contracts.md](plugin-visualization-contracts.md) |
 | Tests | [tests/test_sloppak.py](../tests/test_sloppak.py), [tests/test_sloppak_convert.py](../tests/test_sloppak_convert.py) |
-
-> **Note on older section references.** Some inline code comments in this repo cite section
-> numbers from the previous version of this document (e.g. "sloppak-spec §5.3"). The external spec
-> renumbered its sections, so those citations are approximate — find the topic by name in the
-> [feedpak spec](https://github.com/got-feedback/feedpak-spec/blob/main/spec/feedpak-v1.md)
-> rather than by the old number.

docs/testing-plugins.md

@@ -0,0 +1,104 @@
+# Testing plugins
+
+Slopsmith has three test surfaces — Python unit/integration tests (pytest), JS plugin-API contract tests (Node), and end-to-end browser tests (Playwright). This doc covers what to use when.
+
+## Test layout
+
+```text
+tests/
+├── conftest.py          Shared pytest fixtures (isolate_logging)
+├── test_plugins.py      Plugin loader + load_sibling + collision tests (includes reset_plugin_state)
+├── test_song.py         Wire-format serialization round-trips
+├── test_*.py            Per-feature backend tests
+├── js/                  Node --test JS plugin-API contract tests
+└── browser/             Playwright end-to-end tests
+```
+
+## Running tests
+
+```bash
+pytest                              # All Python tests
+pytest tests/test_plugins.py -v     # Specific file
+pytest -k "load_sibling" -v         # Pattern match
+
+npm run test:js                     # Node-native JS contract tests
+npm run install:playwright          # One-time: install Chromium
+npm test                            # Playwright browser tests
+npm run test:headed                 # Playwright with visible browser
+npm run test:debug                  # Playwright inspector
+```
+
+CI runs `pytest` on every push/PR to `main` (Python 3.12).
+
+## Shared fixtures
+
+### `isolate_logging` (in `conftest.py`)
+
+Saves and restores handlers, level, and `propagate` flag on the `slopsmith`, `uvicorn`, `uvicorn.error`, and `uvicorn.access` loggers, plus calls `structlog.reset_defaults()`. **Import into any test module that calls `configure_logging()`** so mutations don't bleed across tests.
+
+```python
+def test_my_log_thing(isolate_logging):
+    configure_logging()
+    # ... assertions
+```
+
+### `reset_plugin_state` (in `test_plugins.py`)
+
+Local fixture used by plugin-loader tests. Saves and restores:
+- `plugins.LOADED_PLUGINS`
+- any `plugin_*` keys in `sys.modules`
+- the bare names the tests simulate (`util`, `extractor`) in `sys.modules`
+- `sys.path` (the loader mutates it)
+
+Also unsets `SLOPSMITH_PLUGINS_DIR` for the test's duration via `monkeypatch` so a CI env that pre-sets it can't leak real user plugins into a tmp-path-driven test.
+
+If you're authoring a plugin that ships top-level helper modules, model new tests on the patterns in `test_plugins.py` — use `reset_plugin_state` to guarantee a clean import slate.
+
+## Backend test patterns
+
+- **Wire-format round-trips.** `test_song.py` is the model: pure serialization tests, no fixtures, narrative docstring. Pattern: build a `Song`/`Arrangement`/`Note`, serialize, deserialize, assert equal.
+- **Loader behaviour.** `test_plugins.py` uses tmp-path-driven plugin roots + `reset_plugin_state` + `_make_plugin` / `_run_load_plugins` helpers. Adopt these helpers for any new loader-touching tests.
+- **Async / WebSocket.** Tests for FastAPI WebSocket endpoints use `httpx.AsyncClient` and `app.websocket_connect()`. See `test_audio.py` and `test_highway_3d_routes.py` for examples.
+
+## JS contract tests (`tests/js/`)
+
+Plain `node --test` files. No browser, no server. Cover the plugin-API surface as exposed on `window.slopsmith` and related globals. Run with `npm run test:js`.
+
+Use these when a plugin needs to assert against the API contract without spinning up a real browser. They run in seconds; CI can grow these without slowing.
+
+## Browser tests (`tests/browser/`)
+
+Playwright + Chromium. `playwright.config.ts` runs serially (`workers: 1`) and boots a real Slopsmith instance via Docker Compose. Traces / video on failure.
+
+What's currently covered: page load and keyboard shortcuts. **No plugin E2E patterns yet** — if you're adding the first one for your plugin, set the precedent. Suggested structure:
+
+```ts
+import { test, expect } from '@playwright/test';
+
+test('my plugin loads its navbar entry', async ({ page }) => {
+    await page.goto('/');
+    await expect(page.getByRole('link', { name: 'My Plugin' })).toBeVisible();
+});
+
+test('my plugin shortcut fires', async ({ page }) => {
+    await page.goto('/#plugin-my_plugin');
+    await page.keyboard.press('k');
+    await expect(page.getByTestId('my-plugin-toggle')).toHaveAttribute('aria-pressed', 'true');
+});
+```
+
+Prefer `data-testid` over text-based selectors so refactors don't break tests.
+
+## Debugging
+
+- **Browser console shortcut inventory.** `_listShortcuts()` prints every registered shortcut, its scope, and source.
+- **`LOG_FORMAT=json pytest`** — get machine-readable test logs.
+- **`pytest -s`** — disable output capture (handy for `print()`-style debug, though prefer `log.debug()` in production code).
+- **Playwright trace viewer** — `npx playwright show-trace test-results/.../trace.zip` after a failure.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [plugin-logging.md](plugin-logging.md) — `context["log"]` and why `print()` breaks the logging pipeline
+- [plugin-sibling-imports.md](plugin-sibling-imports.md) — `load_sibling` and the collision tests
+- [plugin-keyboard-shortcuts.md](plugin-keyboard-shortcuts.md) — `window.registerShortcut` and `_listShortcuts()`

docs/websocket-protocol.md

@@ -0,0 +1,44 @@
+# Highway WebSocket protocol reference
+
+The highway WebSocket at `/ws/highway/{filename}?arrangement={index}` streams a song's chart data to the player. Plugins that drive their own highway, replace the renderer (see [plugin-visualization-contracts.md](plugin-visualization-contracts.md)), or consume the stream directly all read these frames.
+
+## Message order
+
+Each connection receives the following JSON frames, roughly in this order:
+
+| Message | Shape | Description |
+|---------|-------|-------------|
+| `loading` | `{ type: 'loading', stage }` | Status/progress message during extraction or conversion. |
+| `song_info` | `{ type, title, artist, arrangement, arrangement_index, arrangements, duration, tuning, capo, format, audio_url, audio_error, stems }` | Song metadata. `arrangements` is the full list for the switcher. `audio_url` is `null` when audio is unavailable, in which case `audio_error` is non-null; otherwise `audio_error` is `null`. `stems` is always present — an empty array for non-sloppak songs or sloppak songs with no split stems. `tuning` is an array whose length depends on the source arrangement (typically 6 for guitar, 4 for bass, but extended-range GP imports can be 7/8 for guitar or 5/6 for bass — use `highway.getStringCount()` for the authoritative count). |
+| `beats` | `{ type, data: [{ time, measure }] }` | Beat timestamps with measure numbers. |
+| `sections` | `{ type, data: [{ time, name }] }` | Named sections (Intro, Verse, Chorus, etc.). |
+| `anchors` | `{ type, data: [{ time, fret, width }] }` | Fret zoom anchors. |
+| `chord_templates` | `{ type, data: [{ name, frets: [6] }] }` | Named chord shapes. |
+| `lyrics` | `{ type, data: [{ w, t, d }] }` | Syllables: `w`=word, `t`=time, `d`=duration. `-` joins to previous, `+` = line break. |
+| `tone_changes` | `{ type: 'tone_changes', base, data: [{ time, name }] }` | Optional — tone change events relative to the arrangement base tone; only sent if tones were found. |
+| `notes` | `{ type, data: [{ t, s, f, sus, ho, po, sl, bn, ... }] }` | Single notes. |
+| `chords` | `{ type, data: [{ t, notes: [{ s, f, sus, ... }] }] }` | Chord events. |
+| `phrases` | `{ type, data: [{ start_time, end_time, max_difficulty, levels: [...] }], total }` | Optional — per-phrase difficulty ladder for master-difficulty slider (slopsmith#48). Only sent when the source chart carries multi-level phrase data (legacy archive / phrase-aware sloppak). Sent in chunks (`data` is a batch, `total` is the full count across messages) to avoid multi-MB single frames. Absent for GP imports and legacy sloppak; consumers must treat missing message as "single fixed difficulty — slider disabled". |
+| `ready` | `{ type: 'ready' }` | All data sent — safe to finalize and start rendering. |
+
+## Delivery guarantees
+
+Message delivery is **incremental**. You may receive `loading` updates and `lyrics` before note/chord payloads. `tone_changes` comes after `lyrics` when present and may be omitted entirely. **Do not finalize rendering until you receive `ready`.**
+
+## Consumer notes
+
+- **Tuning array length follows arrangement.** 6 strings for guitar, 4 for bass, more for extended-range GP imports. Use `highway.getStringCount()` for the authoritative count rather than `tuning.length` (which can be the RS-XML padded 6-string form).
+- **Chord templates are static.** Every `chord_id` referenced by `chords` is guaranteed to be present in `chord_templates`.
+- **Notes carry technique fields.** `ho` = hammer-on, `po` = pull-off, `sl` = slide target, `bn` = bend amount. The full set is defined in `lib/song.py`.
+- **Multiple connections are supported.** Split-screen panels, lyrics panes, and jumping-tab panes each open their own WebSocket. By design — don't try to multiplex.
+
+## Phrase payload (slopsmith#48)
+
+`phrases.data` is an array of phrase objects. Each phrase has `start_time`, `end_time`, `max_difficulty`, and `levels`. Each `level` has `difficulty`, `notes`, `chords`, `anchors`, `handshapes` — fully scoped to that phrase. The master-difficulty slider applies a single difficulty across all phrases by selecting the matching level.
+
+## Related
+
+- [PLUGIN_AUTHORING.md](PLUGIN_AUTHORING.md) — guide index
+- [plugin-visualization-contracts.md](plugin-visualization-contracts.md) — bundle shape passed to `draw()`
+- [sloppak-spec.md](sloppak-spec.md) — sloppak format these messages are derived from
+- `lib/song.py` — server-side `Note`, `Chord`, `Arrangement`, `Song` data models

lib/audio.py

@@ -7,7 +7,7 @@ import shutil
 import subprocess
 from pathlib import Path
 
-log = logging.getLogger("feedBack.lib.audio")
+log = logging.getLogger("slopsmith.lib.audio")
 
 # Maximum length of any single decoder-error fragment that we surface to
 # the client. ffmpeg can emit multi-kB build-configuration / version
@@ -123,7 +123,7 @@ def _scrub_quoted_match(match: re.Match) -> str:
 
 def _bundled_bin_dir() -> Path | None:
     """Resolve the desktop bundle's resources/bin/ directory if we're
-    running inside one. Layout: resources/feedBack/lib/audio.py →
+    running inside one. Layout: resources/slopsmith/lib/audio.py →
     resources/bin/. Gate on vgmstream-cli's presence so we don't
     misidentify random parent dirs (e.g. Docker's `/bin`, dev
     layouts where parents[2] resolves to the repo root) — vgmstream-cli
@@ -284,7 +284,7 @@ def _scrub_paths(text: str, *paths: str) -> str:
     """Replace absolute filesystem paths in `text` with their basenames.
 
     Decoder error strings get joined into the RuntimeError that
-    `convert_wem` raises, and feedBack surfaces that text in the
+    `convert_wem` raises, and slopsmith surfaces that text in the
     browser as `audio_error`. Leaking install / user / DLC paths to the
     client is a needless info disclosure, so before any decoder error
     leaves this module we strip absolute paths down to their final

lib/diagnostics_bundle.py

@@ -130,7 +130,7 @@ ENV_ALLOWLIST = (
     "LOG_LEVEL",
     "LOG_FORMAT",
     "LOG_FILE",
-    "FEEDBACK_RUNTIME",
+    "SLOPSMITH_RUNTIME",
     "PORT",
     "HOST",
     "TZ",
@@ -154,13 +154,13 @@ def _safe_json_dumps(obj) -> str:
         return json.dumps({"error": "unserializable payload"}, indent=2)
 
 
-def _system_version(feedBack_version: str, redactor=None) -> dict:
+def _system_version(slopsmith_version: str, redactor=None) -> dict:
     executable = sys.executable
     if redactor is not None:
         executable = redactor.redact_text(executable)
     return {
         "schema": "system.version.v1",
-        "feedBack_version": feedBack_version,
+        "slopsmith_version": slopsmith_version,
         "python": {
             "version": platform.python_version(),
             "implementation": platform.python_implementation(),
@@ -233,7 +233,7 @@ def _summarize_payload(path: str, parsed) -> dict | None:
         py = parsed.get("python") or {}
         os_ = parsed.get("os") or {}
         return {
-            "feedBack": parsed.get("feedBack_version"),
+            "slopsmith": parsed.get("slopsmith_version"),
             "python": py.get("version"),
             "os": os_.get("system"),
         }
@@ -338,7 +338,7 @@ def _git_info(plugin_dir: Path) -> dict | None:
     """Return git short SHA + remote URL for a plugin checkout.
 
     Pure-Python — reads `.git/HEAD` and `.git/config` directly so this
-    works in containers without the `git` binary installed (feedBack's
+    works in containers without the `git` binary installed (slopsmith's
     runtime image is minimal). Plugins are gitlinks (see CLAUDE.md);
     the SHA is the most reliable "what build is this" identifier.
 
@@ -393,7 +393,7 @@ def _system_plugins(loaded_plugins: list[dict], plugins_root: "Path | list[Path]
     show up in the bundle.
 
     *plugins_root* accepts a single Path, a list of Paths (to cover both
-    the built-in ``plugins/`` directory and ``FEEDBACK_PLUGINS_DIR``), or
+    the built-in ``plugins/`` directory and ``SLOPSMITH_PLUGINS_DIR``), or
     None to skip orphan detection entirely.
 
     Plugin directories not in ``LOADED_PLUGINS`` appear in ``orphans``.
@@ -484,7 +484,7 @@ def _system_plugins(loaded_plugins: list[dict], plugins_root: "Path | list[Path]
     # plugin failed to load — common when requirements.txt installs
     # fail in a read-only container). Accepts a single Path, a list of
     # Paths (to cover both the built-in plugins/ dir and
-    # FEEDBACK_PLUGINS_DIR), or None.
+    # SLOPSMITH_PLUGINS_DIR), or None.
     orphans: list[dict] = []
     if plugins_root is not None:
         roots: list[Path] = plugins_root if isinstance(plugins_root, list) else [plugins_root]
@@ -840,11 +840,11 @@ def _redact_value(value: object, redactor: "Redactor") -> object:
 
 
 README_TEMPLATE = """\
-FeedBack Diagnostics Bundle
+Slopsmith Diagnostics Bundle
 ============================
 
 Generated: {exported_at}
-FeedBack: {feedBack_version}
+Slopsmith: {slopsmith_version}
 Runtime:   {runtime_kind}
 Redacted:  {redacted}
 
@@ -1005,7 +1005,7 @@ def _build_files_meta(files: dict[str, bytes]) -> list[dict]:
 
 def _assemble_files_and_notes(
     *,
-    feedBack_version: str,
+    slopsmith_version: str,
     config_dir: Path,
     dlc_dir: Path | None,
     log_file: Path | None,
@@ -1038,7 +1038,7 @@ def _assemble_files_and_notes(
     if include.get("system", True):
         # Pass the redactor so python.executable is redacted when paths
         # should be hidden (it often lives under $HOME or a per-user venv).
-        ver_payload = _safe_json_dumps(_system_version(feedBack_version, redactor=redactor)).encode("utf-8")
+        ver_payload = _safe_json_dumps(_system_version(slopsmith_version, redactor=redactor)).encode("utf-8")
         files["system/version.json"] = ver_payload
         env_payload = _safe_json_dumps(_system_env(redactor=redactor)).encode("utf-8")
         files["system/env.json"] = env_payload
@@ -1125,7 +1125,7 @@ def _assemble_files_and_notes(
             files.update(plugin_files)
 
     # Per-plugin client-side contributions from
-    # window.feedBack.diagnostics.contribute(plugin_id, payload).
+    # window.slopsmith.diagnostics.contribute(plugin_id, payload).
     # Gated on the same "plugins" toggle as backend plugin diagnostics.
     if include.get("plugins", True) and client_contributions and isinstance(client_contributions, dict):
         # Build the set of actually-loaded plugin IDs so we only accept
@@ -1160,7 +1160,7 @@ def _assemble_files_and_notes(
 
 def _make_manifest(
     *,
-    feedBack_version: str,
+    slopsmith_version: str,
     runtime_kind: str,
     redact: bool,
     files: dict[str, bytes],
@@ -1170,7 +1170,7 @@ def _make_manifest(
     return {
         "schema": BUNDLE_SCHEMA,
         "exported_at": _now_iso(),
-        "feedBack_version": feedBack_version,
+        "slopsmith_version": slopsmith_version,
         "runtime": runtime_kind,
         "redacted": redact,
         "files": _build_files_meta(files),
@@ -1181,7 +1181,7 @@ def _make_manifest(
 
 def build_bundle(
     *,
-    feedBack_version: str,
+    slopsmith_version: str,
     config_dir: Path,
     dlc_dir: Path | None,
     log_file: Path | None,
@@ -1198,7 +1198,7 @@ def build_bundle(
 ) -> tuple[bytes, str, dict]:
     """Returns (zip_bytes, filename, manifest_dict)."""
     files, notes, runtime_kind, redactor = _assemble_files_and_notes(
-        feedBack_version=feedBack_version,
+        slopsmith_version=slopsmith_version,
         config_dir=config_dir,
         dlc_dir=dlc_dir,
         log_file=log_file,
@@ -1215,7 +1215,7 @@ def build_bundle(
     )
 
     manifest = _make_manifest(
-        feedBack_version=feedBack_version,
+        slopsmith_version=slopsmith_version,
         runtime_kind=runtime_kind,
         redact=redact,
         files=files,
@@ -1225,7 +1225,7 @@ def build_bundle(
 
     readme = README_TEMPLATE.format(
         exported_at=manifest["exported_at"],
-        feedBack_version=feedBack_version,
+        slopsmith_version=slopsmith_version,
         runtime_kind=runtime_kind,
         redacted=redact,
     )
@@ -1259,13 +1259,13 @@ def build_bundle(
         for path, payload in sorted(files.items()):
             zf.writestr(path, payload)
 
-    filename = f"feedBack-diag-{feedBack_version}-{_now_filename_slug()}.zip"
+    filename = f"slopsmith-diag-{slopsmith_version}-{_now_filename_slug()}.zip"
     return buf.getvalue(), filename, manifest
 
 
 def preview_bundle(
     *,
-    feedBack_version: str,
+    slopsmith_version: str,
     config_dir: Path,
     dlc_dir: Path | None,
     log_file: Path | None,
@@ -1303,7 +1303,7 @@ def preview_bundle(
         for p in loaded_plugins
     ]
     files, notes, runtime_kind, redactor = _assemble_files_and_notes(
-        feedBack_version=feedBack_version,
+        slopsmith_version=slopsmith_version,
         config_dir=config_dir,
         dlc_dir=dlc_dir,
         log_file=log_file,
@@ -1336,7 +1336,7 @@ def preview_bundle(
                 if key not in files:
                     files[key] = _CALLABLE_PREVIEW_PLACEHOLDER
             # Frontend plugins (those with a screen or script) may call
-            # window.feedBack.diagnostics.contribute() and produce a
+            # window.slopsmith.diagnostics.contribute() and produce a
             # plugins/<id>/client.json in the real export. Advertise a
             # placeholder so the preview file tree is accurate.
             if p.get("has_screen") or p.get("has_script"):
@@ -1377,14 +1377,14 @@ def preview_bundle(
             }).encode("utf-8")
 
     manifest = _make_manifest(
-        feedBack_version=feedBack_version,
+        slopsmith_version=slopsmith_version,
         runtime_kind=runtime_kind,
         redact=redact,
         files=files,
         notes=notes,
         redactor=redactor,
     )
-    filename = f"feedBack-diag-{feedBack_version}-{_now_filename_slug()}.zip"
+    filename = f"slopsmith-diag-{slopsmith_version}-{_now_filename_slug()}.zip"
     return {
         "filename": filename,
         "manifest": manifest,

lib/diagnostics_hardware.py

@@ -16,8 +16,6 @@ import platform
 import subprocess
 from pathlib import Path
 
-from env_compat import getenv_compat
-
 SCHEMA = "system.hardware.v1"
 
 
@@ -43,7 +41,7 @@ def detect_runtime() -> dict:
     nvidia-smi / psutil CPU probes.
     """
     out: dict = {"kind": "bare", "in_docker": False, "in_kubernetes": False}
-    env_runtime = (getenv_compat("FEEDBACK_RUNTIME", "") or "").strip().lower()
+    env_runtime = os.environ.get("SLOPSMITH_RUNTIME", "").strip().lower()
     if env_runtime in ("electron", "docker", "bare"):
         out["kind"] = env_runtime
     if Path("/.dockerenv").exists():
@@ -67,7 +65,7 @@ def detect_runtime() -> dict:
             import psutil  # type: ignore
 
             parent = psutil.Process(os.getppid()).name().lower()
-            if "electron" in parent or "feedBack" in parent:
+            if "electron" in parent or "slopsmith" in parent:
                 out["kind"] = "electron"
         except Exception:
             pass

lib/diagnostics_redact.py

@@ -8,7 +8,7 @@ different salts so tokens cannot be cross-correlated between exports.
 Stable token grammar (see docs/diagnostics-bundle-spec.md):
     <DLC_DIR>          — DLC root path
     <HOME>             — user's home directory
-    <CONFIG_DIR>       — feedBack config dir
+    <CONFIG_DIR>       — slopsmith config dir
     <song:hash8>       — song filename / basename (8 hex chars)
     <ip:hash6>          — IPv4 / IPv6 address (6 hex chars)
     <redacted>          — bearer tokens, key=/token= query strings

lib/drums.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 import logging
 import math
 
-log = logging.getLogger("feedBack.lib.drums")
+log = logging.getLogger("slopsmith.lib.drums")
 
 
 # ── Piece vocabulary ──────────────────────────────────────────────────────────

lib/env_compat.py

@@ -1,38 +0,0 @@
-"""Backward-compatible environment lookup for the slopsmith -> feedBack rename.
-
-Canonical configuration variables are now ``FEEDBACK_*``. Deployments that
-predate the rename may still set the old ``SLOPSMITH_*`` names (docker-compose
-overrides, shell profiles, CI), so we honour those as a fallback. New code
-should always read the canonical ``FEEDBACK_*`` name and let this shim resolve
-the legacy alias.
-
-Flat-importable, no import-time IO or global state (constitution P-V).
-"""
-
-import os
-
-_CANON_PREFIX = "FEEDBACK_"
-_LEGACY_PREFIX = "SLOPSMITH_"
-_TRUE_VALUES = {"1", "true", "yes", "on"}
-
-
-def getenv_compat(name, default=None):
-    """``os.environ.get`` with a legacy ``SLOPSMITH_*`` fallback.
-
-    For a canonical ``FEEDBACK_<X>`` name, returns the value of ``FEEDBACK_<X>``
-    if set, else ``SLOPSMITH_<X>`` if set, else ``default``. Names that do not
-    start with ``FEEDBACK_`` behave exactly like ``os.environ.get``.
-    """
-    value = os.environ.get(name)
-    if value is not None:
-        return value
-    if name.startswith(_CANON_PREFIX):
-        legacy = os.environ.get(_LEGACY_PREFIX + name[len(_CANON_PREFIX):])
-        if legacy is not None:
-            return legacy
-    return default
-
-
-def env_flag_compat(name):
-    """Parse a conventional boolean env flag, honouring the legacy alias."""
-    return (getenv_compat(name, "") or "").strip().lower() in _TRUE_VALUES

lib/gp2midi.py

@@ -8,9 +8,7 @@ import sys
 import tempfile
 from pathlib import Path
 
-from env_compat import getenv_compat
-
-log = logging.getLogger("feedBack.lib.gp2midi")
+log = logging.getLogger("slopsmith.lib.gp2midi")
 
 import guitarpro
 from midiutil import MIDIFile
@@ -154,15 +152,15 @@ def _find_soundfont() -> str | None:
     """Locate a .sf2 soundfont for MIDI rendering.
 
     Precedence:
-      1. ``FEEDBACK_SOUNDFONT`` env var (user override / desktop-app-supplied)
+      1. ``SLOPSMITH_SOUNDFONT`` env var (user override / desktop-app-supplied)
       2. Bundled ``<RESOURCESPATH>/soundfonts/*.sf2`` (Electron desktop builds)
       3. Common system locations per OS.
     """
-    override = getenv_compat("FEEDBACK_SOUNDFONT")
+    override = os.environ.get("SLOPSMITH_SOUNDFONT")
     if override:
         if os.path.isfile(override):
             return override
-        log.warning("FEEDBACK_SOUNDFONT is set to %r but that file does not exist; falling back to other sources", override)
+        log.warning("SLOPSMITH_SOUNDFONT is set to %r but that file does not exist; falling back to other sources", override)
 
     resources = os.environ.get("RESOURCESPATH")
     if resources:
@@ -189,10 +187,10 @@ def _find_soundfont() -> str | None:
     elif sys.platform == "win32":
         appdata = os.environ.get("APPDATA")
         if appdata:
-            # "FeedBack" matches feedBack-desktop's Electron productName
-            # (app.getPath('userData') resolves to %APPDATA%\FeedBack on Windows).
+            # "Slopsmith" matches slopsmith-desktop's Electron productName
+            # (app.getPath('userData') resolves to %APPDATA%\Slopsmith on Windows).
             for pattern in (
-                os.path.join(appdata, "FeedBack", "soundfonts", "*.sf2"),
+                os.path.join(appdata, "Slopsmith", "soundfonts", "*.sf2"),
                 os.path.join(appdata, "SoundFonts", "*.sf2"),
             ):
                 candidates += sorted(glob.glob(pattern))
@@ -220,16 +218,16 @@ def _soundfont_install_hint() -> str:
             "or FluidR3_GM from musical-artifacts.com) and either place the .sf2 "
             "file in /usr/local/share/sounds/sf2/ (Intel) or "
             "/opt/homebrew/share/sounds/sf2/ (Apple Silicon), or set the "
-            "FEEDBACK_SOUNDFONT environment variable to its full path."
+            "SLOPSMITH_SOUNDFONT environment variable to its full path."
         )
     if sys.platform == "win32":
         return (
             "Download a soundfont (e.g. GeneralUser GS from schristiancollins.com or "
             "FluidR3_GM from musical-artifacts.com) and either place the .sf2 file in "
-            "%APPDATA%\\FeedBack\\soundfonts\\ or set the FEEDBACK_SOUNDFONT "
+            "%APPDATA%\\Slopsmith\\soundfonts\\ or set the SLOPSMITH_SOUNDFONT "
             "environment variable to its full path."
         )
-    return "Set FEEDBACK_SOUNDFONT to the full path of a .sf2 file."
+    return "Set SLOPSMITH_SOUNDFONT to the full path of a .sf2 file."
 
 
 def _fluidsynth_install_hint() -> str:

lib/gp2notation.py

@@ -19,8 +19,8 @@ bar-indexed tempo map, per-beat rhythm durations (dots + tuplets; see
 ``_beat_secs`` for the one deliberate double-dot divergence), and
 ``_note_midi`` — so the
 notation beats line up with the RS-XML notes the highway plays (see
-feedBack#618 for the longer-term goal of sharing the note-building walk
-itself, and feedBack#261 for the time-signature-denominator pitfalls the
+slopsmith#618 for the longer-term goal of sharing the note-building walk
+itself, and slopsmith#261 for the time-signature-denominator pitfalls the
 ``beat_groups`` emission here exists to avoid re-introducing).
 
 Where this plugs in: ``gp2rs_gpx.convert_file`` calls
@@ -43,7 +43,7 @@ from pathlib import Path
 
 import notation as notation_mod
 
-log = logging.getLogger("feedBack.lib.gp2notation")
+log = logging.getLogger("slopsmith.lib.gp2notation")
 
 
 # GPX NoteValue string → notation duration denominator (sloppak-spec §5.3:
@@ -522,10 +522,6 @@ def attach_notation_to_sloppak(sloppak_dir: str | Path, arr_id: str, payload: di
         json.dumps(payload, separators=(",", ":")), encoding="utf-8"
     )
     entry["notation"] = filename
-    # Stamp the format version while we're rewriting the manifest (spec §4),
-    # without downgrading an existing (possibly higher) declared version.
-    from sloppak import FEEDPAK_VERSION
-    manifest.setdefault("feedpak_version", FEEDPAK_VERSION)
     manifest_path.write_text(
         yaml.safe_dump(manifest, sort_keys=False, allow_unicode=True),
         encoding="utf-8",

lib/gp2rs.py

@@ -1,6 +1,5 @@
 """Convert Guitar Pro files (.gp5/.gp4/.gp3) to arrangement XML."""
 
-import json
 import logging
 import re
 import xml.etree.ElementTree as ET
@@ -10,7 +9,7 @@ from pathlib import Path
 
 import guitarpro
 
-log = logging.getLogger("feedBack.lib.gp2rs")
+log = logging.getLogger("slopsmith.lib.gp2rs")
 
 _YEAR_RE = re.compile(r"\b(1[89]\d{2}|20\d{2})\b")
 
@@ -57,8 +56,6 @@ class RsNote:
     fret: int
     sustain: float = 0.0
     bend: float = 0.0
-    bend_intent: int = 0
-    bend_values: list | None = None
     slide_to: int = -1
     slide_unpitch_to: int = -1
     hammer_on: bool = False
@@ -72,9 +69,6 @@ class RsNote:
     tremolo: bool = False
     tap: bool = False
     link_next: bool = False
-    # Teaching mark (§6.2.2): fret-hand finger (-1 unset, 0 thumb..4 pinky).
-    # Display only — never used for grading.
-    fret_finger: int = -1
 
 
 @dataclass
@@ -197,77 +191,6 @@ def _duration_to_seconds(duration: guitarpro.Duration, tempo: float) -> float:
     return beats * (60.0 / tempo)
 
 
-# pyguitarpro models bend-point x-positions on 0..BendEffect.maxPosition (12)
-# across the note's duration; y-values are half-quarter-tone units where 12 = 6
-# semitones, so semitones = value / 2.0 (matches the scalar `bend` derivation).
-_GP_BEND_MAX_POSITION = 12
-
-
-def _bend_intent_from_values(values: list[float]) -> int:
-    """Classify a bend gesture (§6.2.1) from its time-ordered semitone values:
-    0 up, 1 release, 2 pre-bend, 3 pre-bend-and-release, 4 round-trip."""
-    if not values:
-        return 0
-    eps = 0.05
-    first, last, peak = values[0], values[-1], max(values)
-    if first > eps:
-        if last <= eps:
-            return 3                      # pre-bent, then released to pitch
-        if last < first - eps:
-            return 1                      # held bend let down
-        return 2                          # pre-bend held
-    if peak > eps and last <= eps:
-        return 4                          # bend up and back down
-    return 0                              # plain bend up
-
-
-def _gp_bend_shape(bend, duration_secs: float):
-    """From a pyguitarpro ``BendEffect``, return ``(peak, intent, curve)``.
-
-    ``peak`` is the bend's peak in semitones (the scalar ``bn``); ``intent`` is
-    the §6.2.1 ``bt`` code; ``curve`` is the time-stamped ``bnv`` list
-    (``[{t: seconds-from-onset, v: semitones}]``) or ``None`` when there's no
-    usable shape (no points, or a zero-length note collapsing every point to
-    ``t=0``)."""
-    pts = sorted(bend.points or [], key=lambda p: p.position)
-    if not pts:
-        return 0.0, 0, None
-    values = [round(p.value / 2.0, 1) for p in pts]
-    peak = round(max(values), 1)
-    intent = _bend_intent_from_values(values)
-    curve = None
-    if duration_secs > 0 and len(pts) >= 2:
-        curve = [
-            {"t": round(duration_secs * (p.position / _GP_BEND_MAX_POSITION), 3),
-             "v": v}
-            for p, v in zip(pts, values)
-        ]
-    return peak, intent, curve
-
-
-def _bend_shape_xml_attrs(n: "RsNote") -> dict:
-    """Optional bend-shape XML attributes for a <note>/<chordNote>, default-
-    omitted: `bendIntent` only when non-zero, `bendValues` (a JSON-encoded
-    [{t,v}] curve) only when present. `_parse_note` (lib/song.py) reads these
-    back so a GP-imported bend curve survives import → wire → highway."""
-    attrs: dict = {}
-    if n.bend_intent:
-        attrs["bendIntent"] = str(int(n.bend_intent))
-    if n.bend_values:
-        attrs["bendValues"] = json.dumps(n.bend_values, separators=(",", ":"))
-    return attrs
-
-
-def _finger_xml_attrs(n: "RsNote") -> dict:
-    """Optional teaching-mark XML attribute for a <note>/<chordNote>: `fretFinger`
-    only when set (!= -1). `_parse_note` (lib/song.py) reads it back so a
-    GP-imported fret-hand finger survives import → wire → highway. Display only;
-    never used for grading (§6.2.2)."""
-    if getattr(n, "fret_finger", -1) != -1:
-        return {"fretFinger": str(int(n.fret_finger))}
-    return {}
-
-
 def _tempo_at_tick(tick: int, tempo_map: list[TempoEvent]) -> float:
     """Get the tempo at a given tick."""
     result = tempo_map[0].tempo
@@ -537,69 +460,6 @@ def _gp_string_to_rs(gp_string: int, num_strings: int) -> int:
     return num_strings - gp_string
 
 
-def _gp_finger_to_rs(fingering) -> int:
-    """Coerce a pyguitarpro ``Fingering`` enum to an RS fret-hand finger int.
-
-    Fingering values are ``unknown=-2, open=-1, thumb=0, index=1, middle=2,
-    annular=3, little=4`` — already the RS finger integers for 0..4. Anything
-    open/unknown/out-of-range collapses to ``-1`` (unset), so we never invent a
-    finger. Teaching mark only (§6.2.2); never used for grading."""
-    val = getattr(fingering, "value", fingering)
-    if not isinstance(val, int) or val < 0 or val > 4:
-        return -1
-    return val
-
-
-def _chord_fingers(chord, frets: list[int], num_strings: int) -> list[int]:
-    """Per-string fingering for a chord template, in RS string order.
-
-    pyguitarpro exposes the chord-diagram voicing on ``beat.effect.chord``:
-    ``chord.strings`` is a per-string fret list indexed 0 = highest string
-    (GP string 1), -1 = unplayed; ``chord.fingerings`` is the parallel list
-    of :class:`guitarpro.Fingering` enums (``open=-1, thumb=0, index=1,
-    middle=2, annular=3, little=4`` — already the RS finger integers). The
-    fingerings list may carry one trailing extra entry, so we only read the
-    first ``len(strings)`` of it.
-
-    Returns a list the same width as ``frets`` (RS string index 0 = low).
-    Only strings that are actually played in this template (``frets[rs] >= 0``)
-    get a finger; everything else stays -1. A chord without a populated
-    voicing yields all -1, so diagram-less charts are unchanged.
-    """
-    fingers = [-1] * len(frets)
-    strings = getattr(chord, "strings", None) or []
-    fingerings = getattr(chord, "fingerings", None) or []
-    for i, fret in enumerate(strings):
-        if fret is None or fret < 0:
-            continue  # string not part of the voicing
-        rs = _gp_string_to_rs(i + 1, num_strings)
-        if not (0 <= rs < len(frets)) or frets[rs] < 0:
-            continue
-        if i < len(fingerings):
-            val = getattr(fingerings[i], "value", fingerings[i])
-            fingers[rs] = val if isinstance(val, int) else -1
-    return fingers
-
-
-def _chord_diagram_frets(chord, num_strings: int, width: int) -> list[int]:
-    """RS-string-ordered absolute frets of the chord DIAGRAM voicing, padded to
-    ``width`` with -1.
-
-    Used to confirm the diagram describes the voicing actually played before
-    enriching a template — mirrors the GP8 exact fret-pattern guard. pyguitarpro
-    stores absolute frets in ``chord.strings`` (``firstFret`` is display-only),
-    so the result compares directly against the played ``frets``."""
-    out = [-1] * width
-    strings = getattr(chord, "strings", None) or []
-    for i, fret in enumerate(strings):
-        if fret is None or fret < 0:
-            continue
-        rs = _gp_string_to_rs(i + 1, num_strings)
-        if 0 <= rs < width:
-            out[rs] = fret
-    return out
-
-
 def _is_bass_track(track: guitarpro.Track) -> bool:
     """Detect whether a GP track is a bass.
 
@@ -825,13 +685,12 @@ def convert_track(
                     # Techniques
                     eff = note.effect
                     if eff.bend and eff.bend.points:
-                        # `bn` is the peak; `bnv`/`bt` describe the shape over
-                        # time (§6.2.1). semitones = value / 2 (maxValue 12 = 6
-                        # semitones); the old /100.0 made every bend round to 0.
-                        peak, intent, curve = _gp_bend_shape(eff.bend, dur)
-                        rn.bend = peak
-                        rn.bend_intent = intent
-                        rn.bend_values = curve
+                        # pyguitarpro bend point values are in quarter-tones
+                        # (maxValue 12 = 3 whole tones = 6 semitones), so
+                        # semitones = value / 2. The old /100.0 made every bend
+                        # round to 0 (a whole-tone bend is value 4 -> 0.04).
+                        max_bend = max(p.value for p in eff.bend.points)
+                        rn.bend = round(max_bend / 2.0, 1)
 
                     if eff.hammer:
                         # HO vs PO from pitch direction off the prior note on the
@@ -879,11 +738,6 @@ def convert_track(
                     if eff.tremoloPicking:
                         rn.tremolo = True
 
-                    # Fret-hand fingering -> fg teaching mark (§6.2.2). Same
-                    # Fingering enum + value convention as the chord path.
-                    rn.fret_finger = _gp_finger_to_rs(
-                        getattr(eff, "leftHandFinger", None))
-
                     # Whammy / tremolo bar (beat-level dive/raise). RS has no
                     # whammy attribute, so approximate the pitch movement as an
                     # unpitched slide: a dive slides down, a raise slides up, by
@@ -974,44 +828,17 @@ def convert_track(
                     fret_key = tuple(frets)
 
                     if fret_key not in chord_template_map:
+                        # Try to get chord name from GP
+                        chord_name = ""
+                        if beat.effect and beat.effect.chord:
+                            chord_name = beat.effect.chord.name or ""
                         idx = len(chord_templates)
                         chord_templates.append(ChordTemplate(
-                            name="",
+                            name=chord_name,
                             frets=list(frets),
                             fingers=[-1] * width,
                         ))
                         chord_template_map[fret_key] = idx
-                    else:
-                        idx = chord_template_map[fret_key]
-
-                    # Enrich the template from the GP chord diagram attached to
-                    # this beat — but ONLY when the diagram describes the voicing
-                    # actually played (same width-normalized fret pattern). A
-                    # mismatched chord label/diagram would otherwise mis-name /
-                    # finger the played template, and the back-fill would spread
-                    # it to other strums of the same played pattern. Mirrors the
-                    # GP8 exact fret-pattern guard.
-                    #
-                    # Name and fingers back-fill INDEPENDENTLY: a name-only first
-                    # annotation must not block a later beat that carries fingers
-                    # (and vice versa). Back-fill any still-blank field so the
-                    # data attaches regardless of which strum carries it.
-                    if beat.effect and beat.effect.chord:
-                        gpc = beat.effect.chord
-                        # Compare over the FULL string span (played width vs the
-                        # track's string count) so a diagram that frets an
-                        # extended string the played voicing doesn't use counts
-                        # as a mismatch instead of being silently trimmed.
-                        _w = max(len(frets), num_strings)
-                        _played = frets + [-1] * (_w - len(frets))
-                        if _chord_diagram_frets(gpc, num_strings, _w) == _played:
-                            ct = chord_templates[idx]
-                            if not ct.name and gpc.name:
-                                ct.name = gpc.name
-                            if all(f < 0 for f in ct.fingers):
-                                fingers = _chord_fingers(gpc, frets, num_strings)
-                                if any(f >= 0 for f in fingers):
-                                    ct.fingers = fingers
 
                     rs_chords.append(RsChord(
                         time=t,
@@ -1122,19 +949,9 @@ def _build_xml(
 
     # Tuning. RS2014 schema names 6 string slots; we always emit those
     # for compatibility, and emit additional string6+ attributes (up to
-    # `len(tuning)-1`) for 7+ string arrangements. FeedBack parses
+    # `len(tuning)-1`) for 7+ string arrangements. Slopsmith parses
     # them; the format ignores them.
-    #
-    # `stringCount` records the AUTHORITATIVE string count (== len(tuning)),
-    # because the 6-slot padding above erases the 4-vs-5-vs-6-string
-    # distinction for standard tunings (a 4-string bass, 5-string bass and
-    # 6-string guitar are otherwise byte-identical, all string0..5 = 0).
-    # parse_arrangement trims `tuning` back to this on read so downstream
-    # string-count derivation (song.arrangement_string_count, the editor's
-    # _stringCountFor) sees the real width instead of guessing. RS2014 and
-    # any other consumer simply ignore the unknown attribute.
     tuning_el = ET.SubElement(root, "tuning")
-    tuning_el.set("stringCount", str(len(tuning)))
     for i in range(max(6, len(tuning))):
         tuning_el.set(f"string{i}", str(tuning[i] if i < len(tuning) else 0))
     ET.SubElement(root, "capo").text = "0"
@@ -1204,8 +1021,6 @@ def _build_xml(
             "tap": "1" if n.tap else "0",
             "ignore": "0",
         }
-        attrs.update(_bend_shape_xml_attrs(n))
-        attrs.update(_finger_xml_attrs(n))
         ET.SubElement(notes_el, "note", **attrs)
 
     # Chords
@@ -1216,30 +1031,25 @@ def _build_xml(
                                  chordId=str(ch.template_idx),
                                  highDensity="0", strum="down")
         for cn in ch.notes:
-            cn_attrs = {
-                "time": f"{cn.time:.3f}",
-                "string": str(cn.string),
-                "fret": str(cn.fret),
-                "sustain": f"{cn.sustain:.3f}",
-                "bend": f"{cn.bend:.1f}" if cn.bend else "0",
-                "hammerOn": "1" if cn.hammer_on else "0",
-                "pullOff": "1" if cn.pull_off else "0",
-                "slideTo": str(cn.slide_to),
-                "slideUnpitchTo": str(cn.slide_unpitch_to),
-                "harmonic": "1" if cn.harmonic else "0",
-                "harmonicPinch": "1" if cn.harmonic_pinch else "0",
-                "palmMute": "1" if cn.palm_mute else "0",
-                "mute": "1" if cn.mute else "0",
-                "vibrato": "1" if cn.vibrato else "0",
-                "tremolo": "1" if cn.tremolo else "0",
-                "accent": "1" if cn.accent else "0",
-                "linkNext": "1" if cn.link_next else "0",
-                "tap": "1" if cn.tap else "0",
-                "ignore": "0",
-            }
-            cn_attrs.update(_bend_shape_xml_attrs(cn))
-            cn_attrs.update(_finger_xml_attrs(cn))
-            ET.SubElement(chord_el, "chordNote", **cn_attrs)
+            ET.SubElement(chord_el, "chordNote",
+                          time=f"{cn.time:.3f}",
+                          string=str(cn.string),
+                          fret=str(cn.fret),
+                          sustain=f"{cn.sustain:.3f}",
+                          bend=f"{cn.bend:.1f}" if cn.bend else "0",
+                          hammerOn="1" if cn.hammer_on else "0",
+                          pullOff="1" if cn.pull_off else "0",
+                          slideTo=str(cn.slide_to),
+                          slideUnpitchTo=str(cn.slide_unpitch_to),
+                          harmonic="1" if cn.harmonic else "0",
+                          harmonicPinch="1" if cn.harmonic_pinch else "0",
+                          palmMute="1" if cn.palm_mute else "0",
+                          mute="1" if cn.mute else "0",
+                          vibrato="1" if cn.vibrato else "0",
+                          tremolo="1" if cn.tremolo else "0",
+                          accent="1" if cn.accent else "0",
+                          linkNext="1" if cn.link_next else "0",
+                          tap="1" if cn.tap else "0", ignore="0")
 
     # Anchors
     anchors_el = ET.SubElement(level, "anchors", count=str(len(anchors)))

lib/gp2rs_gpx.py

@@ -1,7 +1,7 @@
 """
 lib/gp2rs_gpx.py — Guitar Pro 6 (.gpx) support shim for gp2rs.
 
-Drop this file into feedBack/lib/ alongside gp2rs.py.
+Drop this file into slopsmith/lib/ alongside gp2rs.py.
 No third-party dependencies — pure Python stdlib only.
 
 Public API mirrors the two functions that the editor plugin calls:
@@ -20,7 +20,7 @@ from pathlib import Path
 
 from safepath import safe_join
 
-_log = logging.getLogger("feedBack.lib.gp2rs_gpx")
+_log = logging.getLogger("slopsmith.lib.gp2rs_gpx")
 
 
 def _safe_filename_stem(name: str) -> str:
@@ -239,20 +239,12 @@ def _gpif_tracks(root: ET.Element) -> list[dict]:
     _bars_by_id = {b.get('id'): b for b in (root.find('Bars') or [])}
     _voices_by_id = {v.get('id'): v for v in (root.find('Voices') or [])}
     _beats_by_id = {b.get('id'): b for b in (root.find('Beats') or [])}
-    _notes_by_id = {n.get('id'): n for n in (root.find('Notes') or [])}
 
     def _note_count_for_raw(raw_idx: int) -> int:
-        # Count of notes that ACTUALLY become RS notes for the track. This is
-        # the single source of truth: list_tracks surfaces it as the 'notes'
-        # field (the importer's per-track preview count) and _auto_select_gpx
-        # uses (count == 0) to skip empty tracks — so the graph is walked once
-        # here, not again in list_tracks.
-        #
-        # Tie-DESTINATION notes are excluded: a tied note is folded into the
-        # previous note as extended sustain (see the `_note_is_tie` skips in
-        # convert_file), so it never becomes a separate RS note. Counting them
-        # made the preview overstate the result (e.g. 260 shown, 241 imported);
-        # excluding them makes the preview match what the user actually gets.
+        # Total note count for the track (sum of notes across all its beats).
+        # This is the single source of truth: list_tracks surfaces it as the
+        # 'notes' field, and _auto_select_gpx uses (count == 0) to skip empty
+        # tracks — so the graph is walked once here, not again in list_tracks.
         n = 0
         for mb in _masterbars:
             bar_ids = mb.findtext('Bars', '').split()
@@ -271,11 +263,9 @@ def _gpif_tracks(root: ET.Element) -> list[dict]:
                     beat = _beats_by_id.get(bid)
                     if beat is None:
                         continue
-                    for nid in beat.findtext('Notes', '').split():
-                        note_el = _notes_by_id.get(nid)
-                        if note_el is not None and _note_is_tie(note_el):
-                            continue
-                        n += 1
+                    notes_text = beat.findtext('Notes', '').strip()
+                    if notes_text:
+                        n += len(notes_text.split())
         return n
 
     result = []
@@ -455,118 +445,6 @@ def _gp6_element_variation_to_midi(element: int, variation: int) -> int | None:
     return _ART_TO_MIDI.get(art_id, art_id)
 
 
-# GPIF chord-diagram <Position finger="..."> names → RS finger integers,
-# matching the editor (E1) + gp2rs/pyguitarpro convention:
-# open/unused = -1, thumb = 0, index = 1, middle = 2, ring = 3, pinky = 4.
-_GPIF_FINGER_MAP = {
-    'none': -1, 'open': -1, '': -1,
-    'thumb': 0,
-    'index': 1,
-    'middle': 2,
-    'ring': 3, 'annular': 3,
-    'pinky': 4, 'little': 4,
-}
-
-# Per-note <LeftFingering> teaching mark (§6.2.2). Unlike the chord-diagram
-# <Position finger=".."> path above, GPIF stores a single note's fret-hand
-# finger as a direct <Note> child element with the classical p-i-m-a-c letter
-# codes (verified against GP8 exports), mapped to the same RS finger integers
-# (open = -1, thumb = 0, index = 1, middle = 2, annular/ring = 3, little = 4).
-_GPIF_LEFT_FINGERING_MAP = {
-    'open': -1, 'none': -1, '': -1,
-    'p': 0, 'thumb': 0,
-    'i': 1, 'index': 1,
-    'm': 2, 'middle': 2,
-    'a': 3, 'annular': 3, 'ring': 3,
-    'c': 4, 'little': 4, 'pinky': 4,
-}
-
-
-def _gpif_left_fingering(note_el) -> int:
-    """Read a GPIF <Note>'s fret-hand finger (<LeftFingering>) -> RS finger int.
-
-    Returns -1 (unset) when absent or unrecognised — never fabricates a finger.
-    Teaching mark only (§6.2.2); never used for grading."""
-    raw = (note_el.findtext('LeftFingering') or '').strip().lower()
-    if not raw:
-        return -1
-    return _GPIF_LEFT_FINGERING_MAP.get(raw, -1)
-
-
-def _rs_string_order(string_pitches: list[int]) -> dict[int, int]:
-    """Map each GPIF string index → RS string index (0 = lowest pitch).
-
-    Mirrors the per-note transform in ``convert_file`` (sort GPIF string
-    indices by open pitch ascending, tiebreak on index, use the rank), so a
-    chord diagram's string indices land on the same RS strings as the played
-    notes regardless of format direction (GP6 .gpx high→low, GP8 .gp low→high).
-    """
-    order = sorted(range(len(string_pitches)),
-                   key=lambda i: (string_pitches[i], i))
-    return {gp: rs for rs, gp in enumerate(order)}
-
-
-def _parse_chord_diagrams(track_el, string_pitches: list[int]) -> dict:
-    """Map fret-pattern tuple → ``{'name', 'fingers'}`` from a track's diagrams.
-
-    GP7/GP8 GPIF stores authored chord diagrams per track under
-    ``Properties/Property[@name="DiagramCollection"]/Items/Item``. Each Item
-    carries the chord name (its ``name`` attribute) and a ``<Diagram>`` with
-    per-string ``<Fret string=.. fret=..>`` plus
-    ``<Fingering><Position finger=.. string=..></Fingering>``. Diagram string
-    indices share the positional space of note ``String`` indices, so they go
-    through the same pitch-rank transform; ``<Fret fret>`` is the absolute fret
-    (``baseFret`` is display-only and not applied).
-
-    Keying by fret pattern (width-normalised to ≥6, exactly like the template
-    build site) keeps the join key consistent with GP5 + the editor's
-    preserve-by-fret-key (E0). Returns ``{}`` when there are no diagrams or no
-    string tuning (orientation/width would be undefined).
-    """
-    diagrams: dict[tuple, dict] = {}
-    if track_el is None or not string_pitches:
-        return diagrams
-    gp_to_rs = _rs_string_order(string_pitches)
-    for item in track_el.findall(
-            './/Property[@name="DiagramCollection"]/Items/Item'):
-        diag = item.find('Diagram')
-        if diag is None:
-            continue
-        rs_frets: dict[int, int] = {}
-        for fr in diag.findall('Fret'):
-            try:
-                gp = int(fr.get('string'))
-                fret = int(fr.get('fret'))
-            except (TypeError, ValueError):
-                continue
-            if fret < 0:
-                continue
-            rs = gp_to_rs.get(gp)
-            if rs is not None:
-                rs_frets[rs] = fret
-        if not rs_frets:
-            continue
-        width = max(6, max(rs_frets) + 1)
-        frets = [-1] * width
-        fingers = [-1] * width
-        for rs, fret in rs_frets.items():
-            frets[rs] = fret
-        for pos in diag.findall('Fingering/Position'):
-            try:
-                gp = int(pos.get('string'))
-            except (TypeError, ValueError):
-                continue
-            rs = gp_to_rs.get(gp)
-            if rs is None or not (0 <= rs < width) or frets[rs] < 0:
-                continue
-            fname = (pos.get('finger') or '').strip().lower()
-            fingers[rs] = _GPIF_FINGER_MAP.get(fname, -1)
-        # First diagram wins for a given voicing (stable, deterministic).
-        diagrams.setdefault(tuple(frets),
-                            {'name': item.get('name', '') or '', 'fingers': fingers})
-    return diagrams
-
-
 def _gpx_percussion_midis(track_el) -> list[int]:
     """Flatten a drumKit ``InstrumentSet``'s articulations into a list of GM
     ``OutputMidiNumber``s, positionally indexed to match a note's
@@ -732,20 +610,6 @@ def _note_has_vibrato(note_el: ET.Element, prop_map: dict) -> bool:
     return 'Vibrato' in prop_map or note_el.find('Vibrato') is not None
 
 
-def _beat_has_tremolo(beat_el: ET.Element) -> bool:
-    """True if a GP7/GP8 beat carries tremolo picking.
-
-    GPIF encodes tremolo picking as a DIRECT beat-level
-    ``<Tremolo>1/8</Tremolo>`` child of ``<Beat>`` (the value is the rate). The
-    RS note model has a single boolean tremolo flag with no rate, so the rate is
-    intentionally ignored — any tremolo-picked beat maps to note tremolo across
-    it. Matched as a direct child (not ``.//``) so it is never confused with the
-    whammy-bar ``VibratoWTremBar`` Property, a separate beat-level effect
-    handled elsewhere.
-    """
-    return beat_el.find('Tremolo') is not None
-
-
 # ---------------------------------------------------------------------------
 # list_tracks — mirrors gp2rs.list_tracks interface
 # ---------------------------------------------------------------------------
@@ -1196,59 +1060,6 @@ def _gpx_bend_scale(root: ET.Element) -> float:
     return 50.0 if peak <= 400 else 2500.0
 
 
-def _gpx_bend_float(tp: dict, name: str):
-    """Read a GPIF bend `<Property><Float>` value from the property map, or None."""
-    el = tp.get(name)
-    if el is None:
-        return None
-    try:
-        return float(el.findtext('Float') or 0)
-    except (ValueError, TypeError):
-        return None
-
-
-def _gpx_bend_shape(tp: dict, divisor: float, sustain: float):
-    """Build ``(peak, intent, curve)`` from a GPIF note's bend Properties (§6.2.1).
-
-    GPIF describes a bend as origin / middle / destination value+offset pairs;
-    `value / divisor` is semitones (divisor auto-detected per file) and the
-    `*Offset` Properties are 0..100 (percent of the note's duration). Produces a
-    bnv curve of up to three points (mapping each offset to seconds-from-onset),
-    or ``None`` when there's no usable shape (no points, flat-zero, or a
-    zero-length note). When an offset Property is absent the stage falls back to
-    an evenly-spaced default (origin 0%, middle 50%, destination 100%).
-
-    NOTE: offset Property names should be confirmed against a real GP8 export;
-    the value path matches the existing scalar-bend extraction either way."""
-    from gp2rs import _bend_intent_from_values  # lazy: gp2rs<->gpx circular
-    stages = (
-        ('BendOriginValue', 'BendOriginOffset', 0.0),
-        ('BendMiddleValue', 'BendMiddleOffset1', 50.0),
-        ('BendDestinationValue', 'BendDestinationOffset', 100.0),
-    )
-    pts = []
-    for vkey, okey, default_off in stages:
-        v = _gpx_bend_float(tp, vkey)
-        if v is None:
-            continue
-        off = _gpx_bend_float(tp, okey)
-        if off is None:
-            off = default_off
-        off = max(0.0, min(100.0, off))
-        pts.append((off, round(v / divisor, 1)))
-    if not pts:
-        return 0.0, 0, None
-    pts.sort(key=lambda p: p[0])
-    values = [v for _, v in pts]
-    peak = round(max(values), 1)
-    intent = _bend_intent_from_values(values)
-    curve = None
-    if peak > 0 and sustain > 0 and len(pts) >= 2:
-        curve = [{"t": round(sustain * (off / 100.0), 3), "v": v}
-                 for off, v in pts]
-    return peak, intent, curve
-
-
 def _resolve_pending_slides(rs_notes, rs_chords, pending_slides):
     """Resolve GP slide flags collected during the beat loop into RS slide
     fields, now that every note on each string is known.
@@ -1382,69 +1193,9 @@ def convert_file(
     track_indices, _piano_merge_map = _find_piano_pairs(track_indices, tracks, names)
 
     output_files = []
-    # All auto-assigned arrangement names handed out so far, so multiple
-    # arrangements get distinct labels (Lead, Rhythm, Combo, Bass, Bass 2, …)
-    # and the name-aware and positional guitar paths never collide.
-    _used_arr_names: set[str] = set()
-
-    def _unique_arr_name(base: str) -> str:
-        """Return `base`, or `base 2`/`base 3`/… if it's already been used."""
-        if base not in _used_arr_names:
-            _used_arr_names.add(base)
-            return base
-        k = 2
-        while f"{base} {k}" in _used_arr_names:
-            k += 1
-        name = f"{base} {k}"
-        _used_arr_names.add(name)
-        return name
-
-    _KEYS_PROGS = set(range(0, 8)) | set(range(16, 24)) | {80, 81, 82, 83}
-
-    def _auto_guitar_hint(track_idx: int):
-        """For a track that auto-resolves to a guitar arrangement, return its
-        role hint: 'lead', 'rhythm', or '' (unhinted). None when the track is
-        NOT an auto-named guitar (explicitly named, bass, drum, vocal, keys).
-        Mirrors the per-track classification in the conversion loop below."""
-        if track_idx >= len(tracks) or names.get(track_idx):
-            return None
-        t = tracks[track_idx]
-        if t['is_drums'] or _is_vocal_track(t):
-            return None
-        low = t['name'].lower()
-        sp = t['string_pitches']
-        prog = t['midi_program']
-        if (isinstance(prog, int) and 32 <= prog <= 39) or (bool(sp) and max(sp) <= 48) or 'bass' in low:
-            return None  # bass
-        if (not sp and prog in _KEYS_PROGS) or any(kw in low for kw in ('piano', 'keys', 'keyboard', 'organ')):
-            return None  # keys
-        if 'lead' in low and 'rhythm' not in low:
-            return 'lead'
-        if 'rhythm' in low and 'lead' not in low:
-            return 'rhythm'
-        return ''  # guitar, no role hint
-
-    # Two-pass guitar role naming, resolved up front so the per-track loop just
-    # looks names up. Reserve every name-hinted Lead/Rhythm first, THEN fill
-    # unhinted guitars into the remaining canonical roles. A single pass would
-    # let an unhinted guitar that appears BEFORE a hinted one steal its role,
-    # pushing the real Lead/Rhythm to a non-canonical "Rhythm 2" that the
-    # downstream name-based path classification doesn't recognise.
-    _guitar_name_by_idx: dict[int, str] = {}
-    _unhinted_guitars: list[int] = []
-    for _ti in track_indices:
-        hint = _auto_guitar_hint(_ti)
-        if hint is None:
-            continue
-        if hint == 'lead':
-            _guitar_name_by_idx[_ti] = _unique_arr_name('Lead')
-        elif hint == 'rhythm':
-            _guitar_name_by_idx[_ti] = _unique_arr_name('Rhythm')
-        else:
-            _unhinted_guitars.append(_ti)
-    for _ti in _unhinted_guitars:
-        base = next((r for r in ('Lead', 'Rhythm', 'Combo') if r not in _used_arr_names), 'Combo')
-        _guitar_name_by_idx[_ti] = _unique_arr_name(base)
+    # Counts of auto-named guitar/bass arrangements so far, so multiple guitars
+    # get distinct RS roles (Lead, Rhythm, Combo, …) instead of all "Lead".
+    _role_counts: dict[str, int] = {}
 
     for track_idx in track_indices:
         if track_idx >= len(tracks):
@@ -1492,12 +1243,16 @@ def convert_file(
             )
             low = track['name'].lower()
             if is_bass or 'bass' in low:
-                arr_name = _unique_arr_name('Bass')
+                _bc = _role_counts.get('bass', 0)
+                _role_counts['bass'] = _bc + 1
+                arr_name = 'Bass' if _bc == 0 else f'Bass {_bc + 1}'
             else:
-                # Guitar role was resolved up front (two-pass, honoring
-                # "lead"/"rhythm" in the GP track name so a Rhythm-before-Lead
-                # file isn't swapped by positional assignment).
-                arr_name = _guitar_name_by_idx.get(track_idx) or _unique_arr_name('Lead')
+                # Distinct guitar roles by appearance order so two guitars
+                # don't both become "Lead": Lead, Rhythm, Combo, then Combo N.
+                _gc = _role_counts.get('guitar', 0)
+                _role_counts['guitar'] = _gc + 1
+                _roles = ('Lead', 'Rhythm', 'Combo')
+                arr_name = _roles[_gc] if _gc < len(_roles) else f'Combo {_gc - 1}'
 
         # Vocal tracks get their own converter — outputs vocals XML, not notes XML
         if is_vocal:
@@ -1522,10 +1277,6 @@ def convert_file(
         rs_chords: list[RsChord] = []
         chord_templates: list[ChordTemplate] = []
         chord_template_map: dict[tuple, int] = {}
-        # Authored chord diagrams (name + per-string fingering) for this track,
-        # keyed by fret pattern so they enrich matching played voicings.
-        chord_diagram_map = _parse_chord_diagrams(
-            track.get('_el'), track['string_pitches'])
         beats_out: list[RsBeat] = []
         sections: list[RsSection] = []
         section_counts: dict[str, int] = {}
@@ -1705,11 +1456,6 @@ def convert_file(
                                         rn.vibrato = True
                                     if 'LeftHandTapping' in _tp or 'Tapped' in _tp:
                                         rn.tap = True
-                                    # Fret-hand fingering -> fg teaching mark
-                                    # (§6.2.2). <LeftFingering> is a direct <Note>
-                                    # child, not a <Property>, so read it off
-                                    # note_el rather than the property map.
-                                    rn.fret_finger = _gpif_left_fingering(note_el)
                                     if 'HarmonicType' in _tp:
                                         _ht = (_tp['HarmonicType'].findtext('HType')
                                                or '').strip().lower()
@@ -1727,21 +1473,21 @@ def convert_file(
                                             rn.pull_off = True
                                         else:
                                             rn.hammer_on = True
-                                    # Bend: `bn` is the peak; `bnv`/`bt` capture
-                                    # the shape over time (§6.2.1). value/divisor
-                                    # = semitones (scale auto-detected per file).
+                                    # Bend: peak amount (GPIF bend value → semitones,
+                                    # scale auto-detected per file in _bend_divisor).
                                     if 'Bended' in _tp:
-                                        # Use the beat duration `dur`, not
-                                        # `rn.sustain` (zeroed for notes <= 0.2s),
-                                        # so short bends keep their bnv curve —
-                                        # matching the GP5 path, which maps over
-                                        # the raw note duration.
-                                        _peak, _intent, _curve = _gpx_bend_shape(
-                                            _tp, _bend_divisor, dur)
-                                        if _peak > 0:
-                                            rn.bend = _peak
-                                            rn.bend_intent = _intent
-                                            rn.bend_values = _curve
+                                        _bv = 0.0
+                                        for _bk in ('BendDestinationValue',
+                                                    'BendMiddleValue', 'BendOriginValue'):
+                                            _be = _tp.get(_bk)
+                                            if _be is not None:
+                                                try:
+                                                    _bv = max(_bv, float(
+                                                        _be.findtext('Float') or 0))
+                                                except (ValueError, TypeError):
+                                                    pass
+                                        if _bv > 0:
+                                            rn.bend = round(_bv / _bend_divisor, 1)
                                     # Slide flags: 1/2 = pitched slide to the next
                                     # note; 4 = slide out down, 8 = out up. Resolved
                                     # post-loop (needs the next note on the string).
@@ -1776,17 +1522,6 @@ def convert_file(
                                     for _bn in beat_rs_notes:
                                         _bn.vibrato = True
 
-                                # Tremolo picking: GP7/GP8 encodes the rate as a
-                                # beat-level <Tremolo>1/8</Tremolo> child. The note
-                                # model has a single tremolo flag (no rate), so map
-                                # any tremolo-picked beat to note tremolo across it.
-                                # Independent of vibrato above — a note can carry
-                                # both. (Beat-level <Tremolo>, not the whammy
-                                # VibratoWTremBar Property, which is handled above.)
-                                if _beat_has_tremolo(beat_el):
-                                    for _bn in beat_rs_notes:
-                                        _bn.tremolo = True
-
                                 if len(beat_rs_notes) == 1:
                                     rs_notes.append(beat_rs_notes[0])
                                 elif len(beat_rs_notes) > 1:
@@ -1798,12 +1533,8 @@ def convert_file(
                                     fkey = tuple(frets_t)
                                     if fkey not in chord_template_map:
                                         chord_template_map[fkey] = len(chord_templates)
-                                        _diag = chord_diagram_map.get(fkey)
                                         chord_templates.append(ChordTemplate(
-                                            name=(_diag['name'] if _diag else ''),
-                                            frets=list(frets_t),
-                                            fingers=(list(_diag['fingers']) if _diag
-                                                     else [-1] * width),
+                                            name='', frets=list(frets_t), fingers=[-1] * width,
                                         ))
                                     rs_chords.append(RsChord(
                                         time=t,
@@ -2383,15 +2114,7 @@ def _auto_select_gpx(tracks: list[dict]) -> tuple[list[int], dict[int, str]]:
         if is_bass:
             selected.append((i, 'bass'))
         elif is_guitar:
-            # Honor "lead"/"rhythm" in the GP track name so two guitars keep
-            # the author's roles instead of being labelled by appearance order
-            # (which swaps a Rhythm-before-Lead file). Unhinted → positional.
-            if 'lead' in name_l and 'rhythm' not in name_l:
-                selected.append((i, 'guitar_lead'))
-            elif 'rhythm' in name_l and 'lead' not in name_l:
-                selected.append((i, 'guitar_rhythm'))
-            else:
-                selected.append((i, 'guitar'))
+            selected.append((i, 'guitar'))
         elif is_keys:
             selected.append((i, 'keys'))
 
@@ -2400,48 +2123,19 @@ def _auto_select_gpx(tracks: list[dict]) -> tuple[list[int], dict[int, str]]:
             if not t['is_drums'] and t.get('note_count', 1) > 0:
                 selected.append((i, 'guitar'))
 
+    indices = []
     name_map = {}
     counts: dict[str, int] = {}
-    RS_NAMES = {'bass': ('Bass',), 'keys': ('Keys',),
-                'drums': ('Drums',), 'vocal': ('Vocals',)}
-    used: set[str] = set()
-
-    def _unique(base: str) -> str:
-        if base not in used:
-            used.add(base)
-            return base
-        k = 2
-        while f"{base} {k}" in used:
-            k += 1
-        used.add(f"{base} {k}")
-        return f"{base} {k}"
-
-    # Two passes so name-hinted Lead/Rhythm guitars reserve their canonical role
-    # BEFORE unhinted guitars are filled in — otherwise an unhinted guitar that
-    # appears before a hinted one steals its role (real Rhythm → "Rhythm 2").
-    # Non-guitar roles are handled in pass 1. `name_map` keys by track index so
-    # this does not affect arrangement (selection) order, computed separately.
-    for idx, role in selected:
-        if role == 'guitar':
-            continue
-        if role == 'guitar_lead':
-            base = 'Lead'
-        elif role == 'guitar_rhythm':
-            base = 'Rhythm'
-        else:
-            counts[role] = counts.get(role, 0) + 1
-            c = counts[role]
-            names_for_role = RS_NAMES.get(role, (role.title(),))
-            base = names_for_role[min(c - 1, len(names_for_role) - 1)]
-            if c > len(names_for_role):
-                base = f"{names_for_role[-1]} {c}"
-        name_map[idx] = _unique(base)
+    RS_NAMES = {'guitar': ('Lead', 'Rhythm', 'Combo'), 'bass': ('Bass',), 'keys': ('Keys',), 'drums': ('Drums',), 'vocal': ('Vocals',)}
 
     for idx, role in selected:
-        if role != 'guitar':
-            continue
-        base = next((r for r in ('Lead', 'Rhythm', 'Combo') if r not in used), 'Combo')
-        name_map[idx] = _unique(base)
+        counts[role] = counts.get(role, 0) + 1
+        c = counts[role]
+        names_for_role = RS_NAMES.get(role, (role.title(),))
+        arr_name = names_for_role[min(c - 1, len(names_for_role) - 1)]
+        if c > len(names_for_role):
+            arr_name = f"{names_for_role[-1]} {c}"
+        indices.append(idx)
+        name_map[idx] = arr_name
 
-    indices = [idx for idx, _role in selected]
     return indices, name_map

lib/gp8_audio_sync.py

@@ -3,7 +3,7 @@ lib/gp8_audio_sync.py — Extract embedded audio and sync data from GP8 (.gp) fi
 
 Guitar Pro 8 can embed a backing track (OGG audio) into a .gp file alongside
 sync points that map bar positions to exact audio timestamps. This module
-extracts both, giving FeedBack:
+extracts both, giving Slopsmith:
 
   1. A real backing track audio file (OGG) — no MIDI synthesis needed
   2. A precise audio_offset (seconds) from the FramePadding value
@@ -45,7 +45,7 @@ import io
 from dataclasses import dataclass, field
 from pathlib import Path
 
-_log = logging.getLogger("feedBack.lib.gp8_audio_sync")
+_log = logging.getLogger("slopsmith.lib.gp8_audio_sync")
 
 # GP8 embeds the backing track under Content/Assets/ as OGG *or* one of
 # several other formats (MP3 is common — e.g. tracks rendered straight

lib/gp_autosync.py

@@ -30,7 +30,7 @@ import zipfile
 import io
 from pathlib import Path
 
-_log = logging.getLogger("feedBack.lib.gp_autosync")
+_log = logging.getLogger("slopsmith.lib.gp_autosync")
 
 # ── Dependency check ──────────────────────────────────────────────────────────
 

lib/logging_setup.py

@@ -1,10 +1,10 @@
-"""Logging configuration for FeedBack.
+"""Logging configuration for Slopsmith.
 
-Call ``configure_logging()`` once at server startup, before any feedBack
+Call ``configure_logging()`` once at server startup, before any slopsmith
 module imports that might emit log records.
 
 Environment variables:
-    LOG_LEVEL   — severity threshold for the ``feedBack.*`` logger tree
+    LOG_LEVEL   — severity threshold for the ``slopsmith.*`` logger tree
                   (default: INFO). Also accepted: DEBUG, WARNING, ERROR.
     LOG_FORMAT  — "json" for structured output (Loki, ELK, Promtail);
                   "text" (default) for human-readable coloured console output.
@@ -43,7 +43,7 @@ def _add_correlation_id(
 
 
 def configure_logging() -> None:
-    """Wire up the feedBack logger hierarchy.
+    """Wire up the slopsmith logger hierarchy.
 
     Safe to call multiple times; always reflects the current LOG_LEVEL,
     LOG_FORMAT, and LOG_FILE environment variables.
@@ -52,7 +52,7 @@ def configure_logging() -> None:
     level = getattr(logging, raw_level, None)
     if not isinstance(level, int):
         sys.stderr.write(
-            f"[feedBack] WARNING: unrecognised LOG_LEVEL={raw_level!r};"
+            f"[slopsmith] WARNING: unrecognised LOG_LEVEL={raw_level!r};"
             " falling back to INFO.\n"
         )
         level = logging.INFO
@@ -60,7 +60,7 @@ def configure_logging() -> None:
     raw_fmt = os.environ.get("LOG_FORMAT", "text").lower()
     if raw_fmt not in ("json", "text"):
         sys.stderr.write(
-            f"[feedBack] WARNING: unrecognised LOG_FORMAT={raw_fmt!r};"
+            f"[slopsmith] WARNING: unrecognised LOG_FORMAT={raw_fmt!r};"
             " falling back to 'text'.\n"
         )
         raw_fmt = "text"
@@ -137,17 +137,17 @@ def configure_logging() -> None:
             handlers.append(fh)
         except OSError as exc:
             sys.stderr.write(
-                f"[feedBack] WARNING: could not open LOG_FILE={log_file!r}: {exc}"
+                f"[slopsmith] WARNING: could not open LOG_FILE={log_file!r}: {exc}"
                 " — continuing with console-only logging.\n"
             )
 
     _uvicorn_names = ("uvicorn", "uvicorn.error", "uvicorn.access")
-    all_loggers = [logging.getLogger("feedBack")] + [
+    all_loggers = [logging.getLogger("slopsmith")] + [
         logging.getLogger(n) for n in _uvicorn_names
     ]
 
     # Collect all unique old handlers across every logger *before* any close so
-    # that a shared handler (feedBack and uvicorn* were intentionally given the
+    # that a shared handler (slopsmith and uvicorn* were intentionally given the
     # same objects) isn't closed while still attached to another logger tree.
     old_handlers: set[logging.Handler] = set()
     for lg in all_loggers:
@@ -160,8 +160,8 @@ def configure_logging() -> None:
     for h in old_handlers:
         h.close()
 
-    # Install fresh handlers on the feedBack root.
-    root = logging.getLogger("feedBack")
+    # Install fresh handlers on the slopsmith root.
+    root = logging.getLogger("slopsmith")
     for h in handlers:
         root.addHandler(h)
     root.setLevel(level)

lib/lyrics_transcribe.py

@@ -23,14 +23,14 @@ Engine selection
 Two transcription paths share a common output:
 
 * `transcribe_vocals_remote(path, server_url, ...)` — POST the vocal
-  stem to the `/align` endpoint on a feedBack-demucs-server (got-feedBack's
+  stem to the `/align` endpoint on a slopsmith-demucs-server (Byron's
   reference server already hosts WhisperX alongside Demucs at the same
   URL).
 
 * `transcribe_vocals_local(path, ...)` — load WhisperX in-process. Heavy
   (~3 GB of model weights for `large-v2` + the wav2vec2 aligner) and
   slow on CPU. Deferred imports of `whisperx`, `torch`, and `soundfile`
-  keep the rest of feedBack free of those dependencies.
+  keep the rest of slopsmith free of those dependencies.
 
 Callers pick between them based on a `whisperx.server_url` config and
 fall back as appropriate. This module does not read config — both
@@ -58,7 +58,7 @@ import logging
 from pathlib import Path
 from typing import Callable, Optional
 
-log = logging.getLogger("feedBack.lib.lyrics_transcribe")
+log = logging.getLogger("slopsmith.lib.lyrics_transcribe")
 
 ProgressCB = Optional[Callable[[float, str, str], None]]
 
@@ -179,7 +179,7 @@ _MIN_WORD_DURATION = 0.05
 
 # Semver for the lyric-transcription artifact contract that gets stamped
 # into the sloppak manifest's `lyric_transcription` block alongside the
-# engine + model. Bump per the semantics defined in feedBack#357 (the
+# engine + model. Bump per the semantics defined in slopsmith#357 (the
 # parent `stem_separation` RFC):
 #   * patch — metadata-only or implementation fixes; no regeneration
 #   * minor — backward-compatible additions

lib/notation.py

@@ -24,7 +24,7 @@ from __future__ import annotations
 import logging
 import math
 
-log = logging.getLogger("feedBack.lib.notation")
+log = logging.getLogger("slopsmith.lib.notation")
 
 
 # ── Vocabulary ────────────────────────────────────────────────────────────────

lib/scan_worker.py

@@ -31,7 +31,7 @@ from tunings import tuning_name
 import sloppak as sloppak_mod
 import loosefolder as loosefolder_mod
 
-log = logging.getLogger("feedBack.scan_worker")
+log = logging.getLogger("slopsmith.scan_worker")
 
 
 def _relpath(f: Path, dlc: Path) -> str:
@@ -53,7 +53,7 @@ def _extract_meta_sloppak(path: Path) -> dict:
     meta["tuning_sort_key"] = sum(offsets)
     meta["tuning_offsets"] = " ".join(str(o) for o in offsets)
     meta["format"] = "sloppak"
-    # `extract_meta` already populates `stem_ids` (feedBack#129);
+    # `extract_meta` already populates `stem_ids` (slopsmith#129);
     # default to empty for older callers / mocks.
     meta.setdefault("stem_ids", [])
     # Compute smart names for sloppak arrangements using name-based fallback
@@ -109,7 +109,7 @@ def _extract_meta_for_file(path: Path, dlc_root=None) -> dict:
     the root it already resolved; in-process callers can pass the resolver
     itself (e.g. `_get_dlc_dir`) to keep the lookup lazy.
 
-    FeedBack reads only its own `.sloppak` format and loose-folder XML
+    Slopsmith reads only its own `.sloppak` format and loose-folder XML
     songs. Encrypted/proprietary archive formats are not supported and are
     silently ignored (empty metadata) rather than decrypted.
     """
@@ -121,7 +121,7 @@ def _extract_meta_for_file(path: Path, dlc_root=None) -> dict:
     if loosefolder_mod.is_loose_song(path):
         root = dlc_root() if callable(dlc_root) else dlc_root
         return _extract_meta_loosefolder(path, root)
-    # Unknown/unsupported shape — return empty metadata. FeedBack never
+    # Unknown/unsupported shape — return empty metadata. Slopsmith never
     # reads encrypted archive formats.
     return {
         "title": "", "artist": "", "album": "", "year": "",

lib/sloppak.py

@@ -15,25 +15,13 @@ from __future__ import annotations
 
 import json
 import logging
-import math
 import shutil
 import threading
 import zipfile
 from dataclasses import dataclass, field
 from pathlib import Path
 
-log = logging.getLogger("feedBack.lib.sloppak")
-
-# The feedpak format version this build targets / writes (manifest
-# `feedpak_version`, a semver string per spec §4). Readers tolerate any version
-# (additive/MINOR compatibility); writers stamp this.
-FEEDPAK_VERSION = "1.2.0"
-
-# Package suffixes. The format is byte-identical regardless of suffix; `.feedpak`
-# is the current write extension, `.sloppak` the legacy one we still read.
-FEEDPAK_EXT = ".feedpak"
-SLOPPAK_EXT = ".sloppak"
-SONG_EXTS = (FEEDPAK_EXT, SLOPPAK_EXT)  # accepted on read/discovery
+log = logging.getLogger("slopsmith.lib.sloppak")
 
 import yaml
 
@@ -45,7 +33,6 @@ from song import (
     Arrangement,
     arrangement_from_wire,
     _finite_float,
-    sanitize_tempos,
 )
 import drums as drums_mod
 import notation as notation_mod
@@ -54,12 +41,8 @@ import notation as notation_mod
 # ── Format detection ──────────────────────────────────────────────────────────
 
 def is_sloppak(path: Path) -> bool:
-    """True if path looks like a song package (zip file or directory).
-
-    Accepts both the current `.feedpak` suffix and the legacy `.sloppak` one —
-    same on-disk format, either form.
-    """
-    return path.name.lower().endswith(SONG_EXTS)
+    """True if path looks like a sloppak (zip file or directory)."""
+    return path.name.lower().endswith(".sloppak")
 
 
 # ── Source resolution (zip unpack cache + directory passthrough) ──────────────
@@ -71,27 +54,6 @@ def is_sloppak(path: Path) -> bool:
 _source_cache: dict[str, tuple[Path, float, int]] = {}
 _source_lock = threading.Lock()
 
-# Full-archive unpacks (zip form) are expensive — they write every stem to
-# disk. Cap how many run at once so a burst (e.g. many plays queued, or a stray
-# caller looping the library) can't saturate disk/CPU, and serialize per-file so
-# two callers never rmtree + re-extract the same dest simultaneously (which
-# would corrupt the half-written dir the other is reading).
-_UNPACK_MAX_CONCURRENCY = 2
-_unpack_semaphore = threading.BoundedSemaphore(_UNPACK_MAX_CONCURRENCY)
-_unpack_locks: dict[str, threading.Lock] = {}
-_unpack_locks_guard = threading.Lock()
-
-
-def _unpack_lock_for(filename: str) -> threading.Lock:
-    """Return a stable per-file lock so concurrent unpacks of the same sloppak
-    serialize instead of racing on the same destination dir."""
-    with _unpack_locks_guard:
-        lk = _unpack_locks.get(filename)
-        if lk is None:
-            lk = threading.Lock()
-            _unpack_locks[filename] = lk
-        return lk
-
 
 def _unpack_zip(zip_path: Path, dest: Path) -> None:
     """Extract a sloppak zip archive into dest, replacing any previous contents.
@@ -164,26 +126,10 @@ def resolve_source_dir(
     if path.is_dir():
         resolved = path
     else:
-        # Zip form — unpack to the cache. Serialize per-file (so concurrent
-        # callers don't rmtree + re-extract the same dest at once) and cap
-        # global unpack concurrency (so a burst can't saturate disk/CPU).
+        # Zip form — unpack to the cache.
         dest = unpack_cache_root / _safe_id(filename)
-        with _unpack_lock_for(filename):
-            # Re-check the cache inside the per-file lock — a prior holder may
-            # have just finished unpacking this exact (mtime, size).
-            with _source_lock:
-                cached = _source_cache.get(filename)
-            if (
-                cached
-                and cached[1] == mtime
-                and cached[2] == size
-                and cached[0].exists()
-            ):
-                resolved = cached[0]
-            else:
-                with _unpack_semaphore:
-                    _unpack_zip(path, dest)
-                resolved = dest
+        _unpack_zip(path, dest)
+        resolved = dest
 
     with _source_lock:
         _source_cache[filename] = (resolved, mtime, size)
@@ -233,97 +179,6 @@ def load_manifest(path: Path) -> dict:
     return _read_manifest_from_zip(path)
 
 
-_COVER_MEDIA_TYPES = {
-    ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
-    ".png": "image/png", ".webp": "image/webp",
-}
-
-
-def _cover_media_type(name: str) -> str:
-    return _COVER_MEDIA_TYPES.get(Path(name).suffix.lower(), "image/jpeg")
-
-
-def read_cover_bytes(
-    path: Path, manifest: dict | None = None
-) -> tuple[bytes, str] | None:
-    """Return ``(image_bytes, media_type)`` for a sloppak's cover, or ``None``.
-
-    Reads ONLY the cover image. For a zipped sloppak this opens the single
-    cover member rather than unpacking the whole archive (stems included), so
-    serving album art on the library grid never triggers a full extraction —
-    the dominant cost behind slow cover loading on scroll.
-    """
-    try:
-        if manifest is None:
-            manifest = load_manifest(path)
-    except Exception:
-        manifest = {}
-    cover_rel = str((manifest or {}).get("cover") or "cover.jpg")
-
-    if path.is_dir():
-        # Directory form — read the file, guarding against escape.
-        cover_path = (path / cover_rel).resolve()
-        try:
-            cover_path.relative_to(path.resolve())
-        except ValueError:
-            return None
-        if cover_path.is_file():
-            try:
-                return cover_path.read_bytes(), _cover_media_type(cover_path.name)
-            except OSError as e:
-                log.warning("sloppak: failed to read cover %r: %s", cover_path, e)
-        return None
-
-    # Zip form — read just the cover member, no unpack. Normalize the manifest
-    # name the way the filesystem would (collapse './' and 'a/../b', backslash →
-    # slash) so a non-canonical-but-valid cover like './cover.jpg' still resolves
-    # to the archive member 'cover.jpg' — matching the old unpack-then-resolve
-    # behavior — and reject zip-slip escape before opening.
-    _zip_root = Path("/_root").resolve()
-    safe = safe_join(_zip_root, cover_rel)
-    # `safe is None` → escape; `safe == _zip_root` → a degenerate name like "."
-    # or "subdir/.." that collapses to the root (member would be "."). Reject
-    # both, mirroring _unpack_zip's degenerate-root guard.
-    if safe is None or safe == _zip_root:
-        log.warning("sloppak: rejected unsafe cover name %r in %r", cover_rel, path)
-        return None
-    member = safe.relative_to(_zip_root).as_posix()
-    try:
-        with zipfile.ZipFile(str(path), "r") as zf:
-            try:
-                data = zf.read(member)
-            except KeyError:
-                return None
-        return data, _cover_media_type(member)
-    except (OSError, zipfile.BadZipFile, RuntimeError) as e:
-        log.warning("sloppak: failed to read cover from zip %r: %s", path, e)
-        return None
-
-
-def _sanitize_time_signatures(events) -> list[dict]:
-    """Clean a time-signature event list (``[{time, ts:[num, den]}]``): keep
-    entries with a finite non-bool ``time`` and a ``ts`` of two integers >= 1,
-    sorted by time. Non-list / all-invalid input -> ``[]``."""
-    out: list[dict] = []
-    if isinstance(events, list):
-        for ev in events:
-            if not isinstance(ev, dict):
-                continue
-            t = ev.get("time")
-            ts = ev.get("ts")
-            if (not isinstance(t, (int, float)) or isinstance(t, bool)
-                    or not math.isfinite(t)):
-                continue
-            if not isinstance(ts, list) or len(ts) != 2:
-                continue
-            if not all(isinstance(x, int) and not isinstance(x, bool) and x >= 1
-                       for x in ts):
-                continue
-            out.append({"time": float(t), "ts": [int(ts[0]), int(ts[1])]})
-        out.sort(key=lambda e: e["time"])
-    return out
-
-
 @dataclass
 class LoadedSloppak:
     """Result of loading a sloppak: the Song object plus stem descriptors."""
@@ -331,9 +186,6 @@ class LoadedSloppak:
     stems: list[dict]           # [{"id": str, "file": str, "default": bool}]
     source_dir: Path
     manifest: dict
-    # The pack's declared format version (manifest `feedpak_version`, a semver
-    # string per spec §4). None when absent (legacy / pre-versioning packs).
-    feedpak_version: str | None = None
     # Parsed `drum_tab.json` payload when the manifest carries a `drum_tab:`
     # key pointing at a readable, schema-valid file. None otherwise (older
     # sloppaks, sloppaks without drums, sloppaks whose drum tab failed to
@@ -345,18 +197,6 @@ class LoadedSloppak:
     # When present, its beats/sections take priority over any beats/sections
     # embedded in the arrangement JSONs.
     song_timeline: dict | None = None
-    # Parsed `keys.json` payload (manifest `keys:` key) — a song-level,
-    # instrument-independent key/scale-change track (spec §7.7). None when
-    # absent / unreadable / malformed. Streamed over the highway WS as a
-    # `keys` message; consumers (renderers, plugins) read it from there.
-    keys: dict | None = None
-    # Sanitized song-level tempo + time-signature maps from `song_timeline.json`
-    # (feedpak 1.2.0). `tempos`: [{time, bpm}]; `time_signatures`: [{time, ts}].
-    # None when absent/empty. Streamed over the highway WS (`tempos` /
-    # `time_signatures` messages); a per-chart arrangement `tempos` overrides
-    # `tempos` for that chart (spec §6.10).
-    tempos: list | None = None
-    time_signatures: list | None = None
     # Maps arrangement id → validated notation payload.  None when no
     # arrangement passed schema validation; a non-empty dict only when at least
     # one arrangement carried a `notation:` sub-key whose file loaded and passed
@@ -367,14 +207,6 @@ class LoadedSloppak:
     # song.arrangements (not to manifest["arrangements"]) — skipped entries are
     # absent so indexing by song.arrangements index is safe.
     arrangement_ids: list[str | None] = field(default_factory=list)
-    # Manifest-relative path to the single full-mix audio file, taken from the
-    # manifest `original_audio:` key (e.g. "original/full.ogg"). This is the
-    # pre-separation mixdown that exists alongside the per-instrument `stems`.
-    # None when the key is absent, points outside source_dir, or the file is
-    # missing on disk. Served to the front-end via the highway WS as
-    # `original_audio_url`; the stems plugin uses it to play the untouched mix
-    # when every stem slider is at unity (and the separate stems otherwise).
-    original_audio: str | None = None
 
 
 def load_song(
@@ -573,8 +405,6 @@ def load_song(
     # already loaded onto the song object — song_timeline is the authoritative
     # source for timeline data in sloppaks that carry it.
     song_timeline_data: dict | None = None
-    tempos_data: list | None = None
-    time_sigs_data: list | None = None
     song_timeline_rel = manifest.get("song_timeline")
     if isinstance(song_timeline_rel, str) and song_timeline_rel:
         try:
@@ -657,13 +487,6 @@ def load_song(
                             )
                             continue
                     song_timeline_data = raw
-            # tempos / time_signatures (feedpak 1.2.0) are independent of the
-            # beats/sections validation above — all are optional — so load them
-            # whenever the payload parsed to a dict.
-            if isinstance(raw, dict):
-                tempos_data = sanitize_tempos(raw.get("tempos")) or None
-                time_sigs_data = _sanitize_time_signatures(
-                    raw.get("time_signatures")) or None
 
     # Optional shared lyrics file. Same safety posture as the drum_tab
     # loader above: constrain the manifest-declared path to source_dir
@@ -754,105 +577,15 @@ def load_song(
             default_on = bool(default_val)
         stems.append({"id": sid, "file": sfile, "default": default_on})
 
-    # Optional keys.json — song-level, instrument-independent key/scale track
-    # (manifest `keys:` key, spec §7.7). Permissive like the other side-files:
-    # missing / unreadable / malformed -> None, never fatal. Stored as a
-    # sanitized {version, events:[{t, key, scale?}]} (finite t, non-empty string
-    # key, sorted) so the highway WS can stream it without re-validating.
-    keys_data: dict | None = None
-    keys_rel = manifest.get("keys")
-    if isinstance(keys_rel, str) and keys_rel:
-        try:
-            k_path = (source_dir / keys_rel).resolve()
-            k_path.relative_to(source_dir.resolve())
-        except ValueError:
-            log.warning("sloppak: keys path %r escapes source_dir — skipped", keys_rel)
-            k_path = None
-        except OSError as e:
-            log.warning("sloppak: keys path resolution failed (%s) — skipped", e)
-            k_path = None
-        if k_path is not None and k_path.exists():
-            try:
-                raw = json.loads(k_path.read_text(encoding="utf-8"))
-            except Exception as e:
-                log.warning("sloppak: failed to parse keys %r: %s", keys_rel, e)
-                raw = None
-            if raw is not None and not isinstance(raw, dict):
-                log.warning("sloppak: keys %r ignored — expected dict, got %s",
-                            keys_rel, type(raw).__name__)
-            elif isinstance(raw, dict):
-                if not isinstance(raw.get("events"), list):
-                    log.warning("sloppak: keys %r ignored — 'events' must be a list", keys_rel)
-                else:
-                    clean_events: list[dict] = []
-                    for ev in raw["events"]:
-                        if not isinstance(ev, dict):
-                            continue
-                        # Drop events with a missing / non-numeric / non-finite
-                        # time rather than silently rewriting them to 0.0 — a
-                        # bad `t` makes the whole event meaningless.
-                        t = ev.get("t")
-                        if (not isinstance(t, (int, float)) or isinstance(t, bool)
-                                or not math.isfinite(t)):
-                            continue
-                        t = float(t)
-                        key = ev.get("key")
-                        if not isinstance(key, str) or not key:
-                            continue
-                        entry = {"t": t, "key": key}
-                        scale = ev.get("scale")
-                        if isinstance(scale, str) and scale:
-                            entry["scale"] = scale
-                        clean_events.append(entry)
-                    clean_events.sort(key=lambda e: e["t"])
-                    # int only — a float version (incl. NaN/Inf, which json.loads
-                    # accepts) would raise on int(); default rather than abort the
-                    # load of an optional side-file.
-                    _ver = raw.get("version")
-                    keys_data = {
-                        "version": _ver if isinstance(_ver, int)
-                                   and not isinstance(_ver, bool) else 1,
-                        "events": clean_events,
-                    }
-
-    _fpv = manifest.get("feedpak_version")
-    # Optional full-mix audio — manifest `original_audio:` key. The single
-    # pre-separation mixdown that ships alongside the per-instrument stems.
-    # Same permissive, path-traversal-guarded posture as drum_tab above: a
-    # missing/escaping/absent file simply leaves the full mix unavailable (the
-    # player falls back to the separate stems) rather than aborting the load.
-    # We store the manifest-relative string so server.py can build its URL the
-    # same way it builds stem URLs (via the /api/sloppak/.../file/ endpoint).
-    original_audio_data: str | None = None
-    original_audio_rel = manifest.get("original_audio")
-    if isinstance(original_audio_rel, str) and original_audio_rel.strip():
-        rel = original_audio_rel.strip()
-        try:
-            oa_path = (source_dir / rel).resolve()
-            oa_path.relative_to(source_dir.resolve())
-        except ValueError:
-            log.warning("sloppak: original_audio path %r escapes source_dir — skipped", rel)
-            oa_path = None
-        except OSError as e:
-            log.warning("sloppak: original_audio path resolution failed (%s) — skipped", e)
-            oa_path = None
-        if oa_path is not None and oa_path.is_file():
-            original_audio_data = rel
-
     return LoadedSloppak(
         song=song,
         stems=stems,
         source_dir=source_dir,
         manifest=manifest,
-        feedpak_version=_fpv if isinstance(_fpv, str) and _fpv else None,
         drum_tab=drum_tab_data,
         song_timeline=song_timeline_data,
-        tempos=tempos_data,
-        time_signatures=time_sigs_data,
-        keys=keys_data,
         notation_by_id=notation_by_id_data,
         arrangement_ids=arrangement_ids_acc,
-        original_audio=original_audio_data,
     )
 
 
@@ -924,6 +657,6 @@ def extract_meta(path: Path) -> dict:
         "arrangements": arrangements,
         "has_lyrics": has_lyrics,
         "stem_count": stem_count,
-        # feedBack#129: per-stem filter needs the id list, not just count.
+        # slopsmith#129: per-stem filter needs the id list, not just count.
         "stem_ids": stem_ids,
     }

lib/song.py

@@ -8,7 +8,7 @@ import logging
 import math
 import xml.etree.ElementTree as ET
 
-log = logging.getLogger("feedBack.lib.song")
+log = logging.getLogger("slopsmith.lib.song")
 
 
 @dataclass
@@ -20,13 +20,6 @@ class Note:
     slide_to: int = -1
     slide_unpitch_to: int = -1
     bend: float = 0.0
-    # Bend shape (§6.2.1, feedpak 1.4.0). `bend` stays the peak magnitude;
-    # `bend_intent` is the gesture (0 up, 1 release, 2 pre-bend,
-    # 3 pre-bend-release, 4 round-trip) and `bend_values` is the optional
-    # time-stamped curve [{t: seconds-from-onset, v: semitones}], authoritative
-    # when present. Both default-omitted on the wire; older readers ignore them.
-    bend_intent: int = 0
-    bend_values: list | None = None
     hammer_on: bool = False
     pull_off: bool = False
     harmonic: bool = False
@@ -43,18 +36,6 @@ class Note:
     slap: bool = False
     right_hand: int = -1
     pick_direction: int = -1
-    # Teaching marks (§6.2.2, feedpak 1.5.0) — display/teaching only; a grader
-    # MUST NEVER use these to judge whether a note was played correctly.
-    # `fret_finger` is the fret-hand finger (-1 unset, 0 thumb, 1..4
-    # index/middle/ring/pinky — same convention as a chord template's fingers);
-    # `strum_group` is a strum/rake key (>= -1, default -1; notes sharing a value
-    # >= 0 are one gesture, with `pick_direction` giving its direction);
-    # `scale_degree` is the note's pitch class as a chromatic offset 0..11 above
-    # the active key's tonic (default -1, MAY be derived from keys.json). All
-    # three default-omitted on the wire; older readers ignore them.
-    fret_finger: int = -1
-    strum_group: int = -1
-    scale_degree: int = -1
     ignore: bool = False
 
 
@@ -65,17 +46,6 @@ class ChordTemplate:
     frets: list[int]
     display_name: str = ""
     arpeggio: bool = False
-    # Harmony annotation (§6.6) — key-independent voicing type, e.g. "open",
-    # "triad", "shell", "drop2", "barre". Display/teaching only, never grading.
-    voicing: str = ""
-    # Harmony annotation (§6.6) — the CAGED shape the fingering derives from,
-    # one of "C"/"A"/"G"/"E"/"D" ("" = unset). Display/teaching only, never grading.
-    caged: str = ""
-    # Harmony annotation (§6.6) — chromatic semitone offsets 0..11 above the
-    # chord root marking the quality-defining tones (e.g. dom7 -> [4, 10]).
-    # snake_case attr; rides the wire as camelCase "guideTones" (like
-    # display_name -> "displayName"). Display/teaching only, never grading.
-    guide_tones: list = field(default_factory=list)
 
 
 @dataclass
@@ -84,10 +54,6 @@ class Chord:
     chord_id: int
     notes: list[Note] = field(default_factory=list)
     high_density: bool = False
-    # Harmony annotation (§6.3.1) — key-dependent harmonic function on the chord
-    # INSTANCE: {rn: str, q: str, deg: int 0..11}. All three keys required when
-    # present (see _validate_fn). Display/teaching only, never grading.
-    fn: dict | None = None
 
 
 @dataclass
@@ -124,10 +90,10 @@ class PhraseLevel:
     """One difficulty tier's worth of note/chord/anchor/hand-shape data for a
     single phrase iteration. the arrangement XML stores these as `<level
     difficulty="N">` blocks that repeat for every difficulty tier the chart
-    author wrote; feedBack used to collapse them to the phrase's
+    author wrote; slopsmith used to collapse them to the phrase's
     maxDifficulty and throw the rest away. Keeping them around lets the
     highway render a "master difficulty" slider that picks a per-phrase
-    difficulty tier at render time (feedBack#48)."""
+    difficulty tier at render time (slopsmith#48)."""
 
     difficulty: int
     notes: list[Note] = field(default_factory=list)
@@ -175,7 +141,7 @@ class Arrangement:
     # `base`/`changes` drive the highway tone-change markers; `definitions`
     # feed the Tones plugin gear panel.
     tones: dict | None = None
-    # arrangement XML <arrangementProperties> flags for smart naming (feedBack feat/arrangement).
+    # arrangement XML <arrangementProperties> flags for smart naming (slopsmith feat/arrangement).
     # Populated from the XML; default False/0 for sloppak / GP-imported sources.
     path_lead: bool = False
     path_rhythm: bool = False
@@ -185,10 +151,6 @@ class Arrangement:
     # RS2014 custom song pitch-shift field (cents). Commonly -1200.0 (one octave
     # down) for extended-range bass arrangements. 0.0 when absent or zero.
     cent_offset: float = 0.0
-    # Per-chart tempo override (§6.10): [{time, bpm}]. None when the chart
-    # follows the song-level tempo; when present a Reader uses it for this
-    # chart and ignores the song-level tempo.
-    tempos: list | None = None
 
 
 @dataclass
@@ -255,23 +217,6 @@ def note_to_wire(n: Note) -> dict:
         out["pkd"] = n.pick_direction
     if n.ignore:
         out["ig"] = True
-    # Bend shape (§6.2.1) — default-omitted: `bt` only when non-zero, `bnv`
-    # only when a curve is present. Mirrors the spec's "omit fields equal to
-    # their default" so a plain bend stays a single `bn` scalar on the wire.
-    if n.bend_intent:
-        out["bt"] = int(n.bend_intent)
-    if n.bend_values:
-        out["bnv"] = [
-            {"t": round(p["t"], 3), "v": round(p["v"], 1)}
-            for p in n.bend_values
-        ]
-    # Teaching marks (§6.2.2) — default-omitted, mirroring rh/pkd above.
-    if n.fret_finger != -1:
-        out["fg"] = n.fret_finger
-    if n.strum_group != -1:
-        out["ch"] = n.strum_group
-    if n.scale_degree != -1:
-        out["sd"] = n.scale_degree
     return out
 
 
@@ -283,19 +228,12 @@ def chord_note_to_wire(cn: Note) -> dict:
 
 
 def chord_to_wire(c: Chord) -> dict:
-    out = {
+    return {
         "t": round(c.time, 3),
         "id": c.chord_id,
         "hd": c.high_density,
         "notes": [chord_note_to_wire(cn) for cn in c.notes],
     }
-    # Harmony function (§6.3.1) — default-omitted, mirroring bend `bnv`. Re-validate
-    # on emit (not just decode) so a directly-constructed Chord can't put a partial
-    # or out-of-range fn on the wire, which would fail the schema's required-keys rule.
-    fn = _validate_fn(c.fn)
-    if fn:
-        out["fn"] = fn
-    return out
 
 
 def anchor_to_wire(a: Anchor) -> dict:
@@ -312,7 +250,7 @@ def hand_shape_to_wire(h: HandShape) -> dict:
 
 
 def chord_template_to_wire(ct: ChordTemplate) -> dict:
-    out = {
+    return {
         "name": ct.name,
         # ChordTemplate.display_name defaults to "" on the dataclass, but
         # the spec defaults displayName to name. Fall back here so
@@ -324,40 +262,6 @@ def chord_template_to_wire(ct: ChordTemplate) -> dict:
         "fingers": list(ct.fingers),
         "frets": list(ct.frets),
     }
-    # Harmony voicing (§6.6) — default-omitted, only when non-empty.
-    if ct.voicing:
-        out["voicing"] = ct.voicing
-    # CAGED shape + guide tones (§6.6) — default-omitted, mirroring voicing.
-    # Sanitize on EMIT too (not just on decode): a directly-constructed template
-    # must not be able to write a non-enum `caged` or an out-of-range `guideTone`
-    # to the wire (the spec constrains caged to C/A/G/E/D and guideTones to 0..11).
-    _caged = _sanitize_caged(ct.caged)
-    if _caged:
-        out["caged"] = _caged
-    _guide_tones = _sanitize_guide_tones(ct.guide_tones)
-    if _guide_tones:
-        out["guideTones"] = _guide_tones
-    return out
-
-
-# §6.6 CAGED shape enum — the only values accepted off the wire.
-_CAGED_SHAPES = ("C", "A", "G", "E", "D")
-
-
-def _sanitize_caged(val) -> str:
-    """A wire `caged` is kept only when it is one of the CAGED shape letters;
-    anything else (None, int, list, unknown string) falls back to ""."""
-    return val if isinstance(val, str) and val in _CAGED_SHAPES else ""
-
-
-def _sanitize_guide_tones(val) -> list:
-    """A wire `guideTones` is kept only as the int entries in 0..11; non-list
-    input, non-ints (bool is an int subclass — rejected), and out-of-range
-    values are dropped so a malformed value can't round-trip."""
-    if not isinstance(val, list):
-        return []
-    return [v for v in val
-            if isinstance(v, int) and not isinstance(v, bool) and 0 <= v <= 11]
 
 
 def _wire_int_optional(v, default=-1):
@@ -375,129 +279,6 @@ def _wire_int_optional(v, default=-1):
             return default
 
 
-def _sanitize_bend_curve(raw):
-    """Clean a time-stamped bend curve (``[{t, v}]``, §6.2.1): keep entries with
-    a finite, non-bool numeric ``t`` and ``v``, coerced to float and sorted by
-    ``t``. Non-list / absent / all-invalid input -> ``None`` so an empty curve
-    round-trips as *omitted*, never ``[]``. ``t`` is seconds from the note
-    onset; ``v`` is semitones (same scale as the scalar ``bn`` peak)."""
-    if not isinstance(raw, list):
-        return None
-    out: list[dict] = []
-    for p in raw:
-        if not isinstance(p, dict):
-            continue
-        t = p.get("t")
-        v = p.get("v")
-        if (not isinstance(t, (int, float)) or isinstance(t, bool)
-                or not math.isfinite(t)):
-            continue
-        if (not isinstance(v, (int, float)) or isinstance(v, bool)
-                or not math.isfinite(v)):
-            continue
-        out.append({"t": float(t), "v": float(v)})
-    if not out:
-        return None
-    out.sort(key=lambda e: e["t"])
-    return out
-
-
-# Natural-note letter -> pitch class (0 = C). Used to parse a keys.json key
-# name's tonic for scale-degree derivation (§6.2.2 / §7.7).
-_KEY_LETTER_PC = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
-
-
-def key_to_tonic_pc(key) -> int | None:
-    """Parse a keys.json key name (§7.7) to its tonic pitch class 0..11.
-
-    Reads only the leading note letter plus optional accidentals — e.g. ``"E"``,
-    ``"Em"``, ``"A#m"``, ``"Bb"``, ``"F#"`` -> 4, 4, 10, 10, 6. The mode/quality
-    suffix (``m``/``maj``/``min``/scale name) is irrelevant to the tonic and is
-    ignored. Returns ``None`` for anything not starting with a valid note letter,
-    so callers can leave ``sd`` unset rather than guess. Used only for teaching
-    marks; never for grading."""
-    if not isinstance(key, str):
-        return None
-    s = key.strip()
-    if not s:
-        return None
-    pc = _KEY_LETTER_PC.get(s[0].upper())
-    if pc is None:
-        return None
-    # Consume any run of accidentals directly after the letter (``#``/``b``/
-    # unicode ♯/♭); stop at the first non-accidental (start of the mode suffix).
-    for ch in s[1:]:
-        if ch in ("#", "♯"):
-            pc += 1
-        elif ch in ("b", "♭"):
-            pc -= 1
-        else:
-            break
-    return pc % 12
-
-
-def scale_degree_for_pitch(midi_pitch: int, tonic_pc: int) -> int:
-    """Chromatic scale degree 0..11 of ``midi_pitch`` above tonic ``tonic_pc``
-    (§6.2.2): the pitch class distance in semitones, 0 = tonic, 7 = fifth.
-    Display/teaching only — MUST NEVER feed a grader."""
-    return (int(midi_pitch) - int(tonic_pc)) % 12
-
-
-# Open-string base MIDI per string count, index 0 = lowest string. Mirrors
-# app.js `_TUNING_BASE_MIDI` / highway_3d `_baseOpenStringMidis` so a derived
-# scale degree agrees with the tuner + open-string labels. `arr.tuning` carries
-# per-string OFFSETS from standard (not absolute pitch), so the sounding open
-# pitch is `base + offset (+ capo)` — see `note_pitch_midi`.
-_TUNING_BASE_MIDI = {
-    4: [28, 33, 38, 43],
-    5: [23, 28, 33, 38, 43],
-    6: [40, 45, 50, 55, 59, 64],
-    7: [35, 40, 45, 50, 55, 59, 64],
-    8: [30, 35, 40, 45, 50, 55, 59, 64],
-}
-
-
-def base_open_string_midis(string_count: int, is_bass: bool) -> list[int]:
-    """Standard open-string base MIDI list for an arrangement, index 0 = lowest.
-
-    Mirrors app.js `_tuningOffsetsToFreqs`: a 4/5-string *bass* uses its own low
-    base, while a 4/5-string non-bass (a guitar voicing) borrows the low strings
-    of the 6-string base; 6/7/8 use their own. Unknown counts fall back to the
-    6-string base."""
-    n = int(string_count)
-    if n in (4, 5):
-        return _TUNING_BASE_MIDI[n] if is_bass else _TUNING_BASE_MIDI[6]
-    return _TUNING_BASE_MIDI.get(n, _TUNING_BASE_MIDI[6])
-
-
-def pitch_from_base(base: list[int], capo: int, tuning: list[int],
-                    string: int, fret: int) -> int | None:
-    """Absolute sounding MIDI for one string+fret, given a precomputed open-string
-    ``base`` (from :func:`base_open_string_midis`) and the arrangement's tuning
-    OFFSETS + capo. None when ``string`` has no tuning entry. Single source of the
-    pitch formula so the per-note hot path can hoist ``base`` out of the loop."""
-    if not (0 <= string < len(tuning)) or not base:
-        return None
-    root = base[string] if string < len(base) else base[-1]
-    return root + int(tuning[string]) + int(capo) + int(fret)
-
-
-def note_pitch_midi(arr: "Arrangement", note: "Note") -> int | None:
-    """Absolute sounding MIDI pitch of ``note`` on arrangement ``arr``, or None
-    when its string index has no tuning entry.
-
-    Pitch = standard base for the string + the arrangement's per-string tuning
-    OFFSET + capo + fret, matching the client's open-string/tuner math. Used to
-    derive the ``sd`` teaching mark (§6.2.2); display only, never grading.
-    O(notes) via ``arrangement_string_count`` — for a whole arrangement, hoist
-    the base with :func:`base_open_string_midis` and call :func:`pitch_from_base`
-    per note instead."""
-    is_bass = "bass" in (arr.name or "").lower()
-    base = base_open_string_midis(arrangement_string_count(arr), is_bass)
-    return pitch_from_base(base, int(getattr(arr, "capo", 0) or 0),
-                           arr.tuning or [], note.string, note.fret)
-
-
 def note_from_wire(d: dict, time: float | None = None) -> Note:
     return Note(
         time=float(d.get("t", time if time is not None else 0.0)),
@@ -507,8 +288,6 @@ def note_from_wire(d: dict, time: float | None = None) -> Note:
         slide_to=int(d.get("sl", -1)),
         slide_unpitch_to=int(d.get("slu", -1)),
         bend=float(d.get("bn", 0.0)),
-        bend_intent=_wire_int_optional(d.get("bt"), 0),
-        bend_values=_sanitize_bend_curve(d.get("bnv")),
         hammer_on=bool(d.get("ho", False)),
         pull_off=bool(d.get("po", False)),
         harmonic=bool(d.get("hm", False)),
@@ -527,38 +306,10 @@ def note_from_wire(d: dict, time: float | None = None) -> Note:
         # the XML side's `_int_optional`.
         right_hand=_wire_int_optional(d.get("rh"), -1),
         pick_direction=_wire_int_optional(d.get("pkd"), -1),
-        # Teaching marks (§6.2.2) — display only, never used for grading.
-        fret_finger=_wire_int_optional(d.get("fg"), -1),
-        strum_group=_wire_int_optional(d.get("ch"), -1),
-        scale_degree=_wire_int_optional(d.get("sd"), -1),
         ignore=bool(d.get("ig", False)),
     )
 
 
-def _validate_fn(raw) -> dict | None:
-    """Validate an optional chord harmony function (§6.3.1).
-
-    Returns a clean ``{"rn", "q", "deg"}`` dict only when ``raw`` is an object
-    with a non-empty ``rn`` string, a non-empty ``q`` string, and an int ``deg``
-    in 0..11. Any malformed / missing-key / out-of-range input -> ``None`` so a
-    partial fn (which would fail the schema's required-keys rule) never rides the
-    wire. Display/teaching only — MUST NEVER feed a grader. Mirrors the
-    drop-to-default tolerance of `_sanitize_bend_curve`."""
-    if not isinstance(raw, dict):
-        return None
-    rn = raw.get("rn")
-    q = raw.get("q")
-    deg = raw.get("deg")
-    if not isinstance(rn, str) or not rn.strip():
-        return None
-    if not isinstance(q, str) or not q.strip():
-        return None
-    # bool is an int subclass — reject it so `deg=True` can't pass as 1.
-    if not isinstance(deg, int) or isinstance(deg, bool) or not (0 <= deg <= 11):
-        return None
-    return {"rn": rn.strip(), "q": q.strip(), "deg": deg}
-
-
 def chord_from_wire(d: dict) -> Chord:
     t = float(d.get("t", 0.0))
     return Chord(
@@ -566,7 +317,6 @@ def chord_from_wire(d: dict) -> Chord:
         chord_id=int(d.get("id", 0)),
         high_density=bool(d.get("hd", False)),
         notes=[note_from_wire(cn, time=t) for cn in d.get("notes", [])],
-        fn=_validate_fn(d.get("fn")),
     )
 
 
@@ -622,7 +372,7 @@ def arrangement_string_count(arr: Arrangement) -> int:
     """Derive the active arrangement's string count.
 
     Used by the server to emit ``stringCount`` in the song_info
-    WebSocket payload (feedBack-plugin-3dhighway#7).
+    WebSocket payload (slopsmith-plugin-3dhighway#7).
 
     The arrangement XML schema always emits 6 ``<tuning>`` slots regardless
     of instrument (bass charts populate `string0`–`string3` and pad
@@ -835,29 +585,6 @@ def _finite_float(value, default: float = 0.0) -> float:
     return v if math.isfinite(v) else default
 
 
-def sanitize_tempos(events) -> list[dict]:
-    """Clean a tempo-event list (``[{time, bpm}]``): keep entries with a finite
-    non-bool ``time`` and a finite ``bpm > 0``, coerced to float and sorted by
-    time. Non-list / all-invalid input -> ``[]``. Shared by the per-chart
-    arrangement ``tempos`` (§6.10) and the song-level ``song_timeline.tempos``."""
-    out: list[dict] = []
-    if isinstance(events, list):
-        for ev in events:
-            if not isinstance(ev, dict):
-                continue
-            t = ev.get("time")
-            bpm = ev.get("bpm")
-            if (not isinstance(t, (int, float)) or isinstance(t, bool)
-                    or not math.isfinite(t)):
-                continue
-            if (not isinstance(bpm, (int, float)) or isinstance(bpm, bool)
-                    or not math.isfinite(bpm) or bpm <= 0):
-                continue
-            out.append({"time": float(t), "bpm": float(bpm)})
-        out.sort(key=lambda e: e["time"])
-    return out
-
-
 def arrangement_to_wire(arr: Arrangement) -> dict:
     """Serialize an Arrangement into a JSON-ready dict matching the wire format."""
     out = {
@@ -885,10 +612,6 @@ def arrangement_to_wire(arr: Arrangement) -> dict:
     # "no tones".
     if arr.tones:
         out["tones"] = arr.tones
-    # Per-chart tempo override (§6.10) — additive; omit when the chart follows
-    # the song-level tempo (empty/None).
-    if arr.tempos:
-        out["tempos"] = list(arr.tempos)
     return out
 
 
@@ -899,7 +622,6 @@ def arrangement_from_wire(d: dict) -> Arrangement:
         tuning=list(d.get("tuning", [0] * 6)),
         capo=int(d.get("capo", 0)),
         cent_offset=_finite_float(d.get("centOffset", 0.0)),
-        tempos=(sanitize_tempos(d.get("tempos")) or None),
         notes=[note_from_wire(n) for n in d.get("notes", [])],
         chords=[chord_from_wire(c) for c in d.get("chords", [])],
         anchors=[
@@ -919,11 +641,7 @@ def arrangement_from_wire(d: dict) -> Arrangement:
                           display_name=ct.get("displayName", ct.get("name", "")),
                           arpeggio=bool(ct.get("arp", False)),
                           fingers=list(ct.get("fingers", [-1] * 6)),
-                          frets=list(ct.get("frets", [-1] * 6)),
-                          voicing=(ct.get("voicing")
-                                   if isinstance(ct.get("voicing"), str) else ""),
-                          caged=_sanitize_caged(ct.get("caged")),
-                          guide_tones=_sanitize_guide_tones(ct.get("guideTones")))
+                          frets=list(ct.get("frets", [-1] * 6)))
             for ct in d.get("templates", [])
         ],
         # `phrases` is optional — absent on single-level sources / older
@@ -1018,18 +736,6 @@ def _chord_high_density(elem: ET.Element) -> bool:
     return False
 
 
-def _parse_bend_values(n):
-    """Read a `bendValues` JSON attribute (GP import emits it; §6.2.1) and
-    sanitize it into a [{t,v}] curve, or None when absent/malformed."""
-    raw = n.get("bendValues")
-    if not raw:
-        return None
-    try:
-        return _sanitize_bend_curve(json.loads(raw))
-    except (ValueError, TypeError):
-        return None
-
-
 def _parse_note(n) -> Note:
     return Note(
         time=_float(n, "time"),
@@ -1039,8 +745,6 @@ def _parse_note(n) -> Note:
         slide_to=_int(n, "slideTo", -1),
         slide_unpitch_to=_int(n, "slideUnpitchTo", -1),
         bend=_float(n, "bend"),
-        bend_intent=_int(n, "bendIntent", 0),
-        bend_values=_parse_bend_values(n),
         hammer_on=_bool(n, "hammerOn"),
         pull_off=_bool(n, "pullOff"),
         harmonic=_bool(n, "harmonic"),
@@ -1057,10 +761,6 @@ def _parse_note(n) -> Note:
         slap=_bool(n, "slap"),
         right_hand=_int_optional(n, "rightHand", -1),
         pick_direction=_int_optional(n, "pickDirection", -1),
-        # Teaching mark (§6.2.2): GP import writes `fretFinger`; strum_group /
-        # scale_degree are authored downstream (editor / derived), not in chart
-        # XML, so they have no attribute to read here.
-        fret_finger=_int_optional(n, "fretFinger", -1),
         ignore=_bool(n, "ignore"),
     )
 
@@ -1090,20 +790,6 @@ def parse_arrangement(xml_path: str) -> Arrangement:
         while el.get(f"string{i}") is not None:
             tuning.append(_int(el, f"string{i}"))
             i += 1
-        # Authoritative string count, written by the GP/RS serializer
-        # (gp2rs._build_xml). The schema pads `<tuning>` to 6 slots, which
-        # erases the 4-vs-5-vs-6-string distinction for standard tunings;
-        # when the real count was recorded, trim the padded tail so
-        # arrangement_string_count / the editor see 4 or 5 instead of 6.
-        # Absent (archive / legacy sources) → leave the 6-slot tuning as-is.
-        sc = el.get("stringCount")
-        if sc is not None:
-            try:
-                n = int(sc)
-            except (TypeError, ValueError):
-                n = 0
-            if 1 <= n <= len(tuning):
-                tuning = tuning[:n]
 
     # Capo
     capo = 0
@@ -1290,7 +976,7 @@ def parse_arrangement(xml_path: str) -> Arrangement:
     def _collect_from_parsed(parsed, t_start, t_end):
         """Append a pre-parsed level's time-clipped slice to the flat
         arrangement lists. Used for the max-mastery merge that preserves
-        the pre-feedBack#48 behaviour for existing consumers."""
+        the pre-slopsmith#48 behaviour for existing consumers."""
         lv_notes, lv_chords, lv_anchors, lv_hand_shapes = _extract_level_slice(
             parsed, t_start, t_end
         )
@@ -1309,7 +995,7 @@ def parse_arrangement(xml_path: str) -> Arrangement:
         _collect_from_parsed(best, 0.0, float("inf"))
 
     # Per-phrase difficulty data for the master-difficulty slider
-    # (feedBack#48). Only populated when the XML has multiple levels AND
+    # (slopsmith#48). Only populated when the XML has multiple levels AND
     # phrase data — left as None for single-level sources so the frontend
     # knows to disable the slider.
     phrases: list[Phrase] | None = None
@@ -1459,7 +1145,7 @@ def _convert_sng_to_xml(extracted_dir: str):
     """No-op stub.
 
     Historically this converted proprietary encrypted ``.notechart`` arrangement
-    files to XML via an external tool. That path has been removed: feedBack
+    files to XML via an external tool. That path has been removed: slopsmith
     reads only its own ``.sloppak`` format and loose-folder/GP/MusicXML-derived
     arrangement XML, and never decodes or decrypts proprietary archives. Kept
     as a no-op so ``load_song`` (which loads plain arrangement XML/JSON from a

lib/songmeta.py

@@ -10,7 +10,7 @@ source of truth, so the change survives both incremental and full rescans.
 only the keys present are overwritten, so an edit of just the title can't blank
 out the artist.
 
-Only feedBack's own ``.sloppak`` format (zip- or directory-form) is writable.
+Only slopsmith's own ``.sloppak`` format (zip- or directory-form) is writable.
 Unknown / unsupported shapes return False and the caller keeps the DB-only
 update.
 """
@@ -49,15 +49,6 @@ def _apply_to_sloppak_manifest(manifest: dict, fields: dict) -> bool:
     if "year" in fields:
         manifest["year"] = _coerce_year(fields["year"])
         dirty = True
-    # Opportunistically declare the format version (spec §4) when we're already
-    # rewriting because a metadata field was supplied. Gated on `dirty` (i.e. a
-    # field was given) so this never forces a *standalone* rewrite with no fields
-    # passed, and `not in` so an existing (possibly higher) version is preserved,
-    # never downgraded. NB `dirty` here means "a field was supplied" — a
-    # supplied-but-identical value already triggers a rewrite (pre-existing).
-    if dirty and "feedpak_version" not in manifest:
-        from sloppak import FEEDPAK_VERSION
-        manifest["feedpak_version"] = FEEDPAK_VERSION
     return dirty
 
 

lib/tailwind_rebuild.py

@@ -1,9 +1,9 @@
 """Regenerate ``static/tailwind.min.css`` over the full installed-plugin set.
 
 Core's committed (and image-baked) stylesheet is built scanning only the
-in-tree plugins. A plugin installed at runtime — into ``FEEDBACK_PLUGINS_DIR``
+in-tree plugins. A plugin installed at runtime — into ``SLOPSMITH_PLUGINS_DIR``
 — ships Tailwind classes the sheet never saw, so it renders unstyled. The
-Play CDN's runtime JIT that used to cover this was removed (feedBack#411),
+Play CDN's runtime JIT that used to cover this was removed (slopsmith#411),
 so we rebuild the sheet ourselves with node + the pinned ``tailwindcss``,
 scanning the baked-in plugins *and* the user plugins dir.
 
@@ -24,9 +24,7 @@ import tempfile
 import threading
 from pathlib import Path
 
-from env_compat import getenv_compat
-
-log = logging.getLogger("feedBack.tailwind")
+log = logging.getLogger("slopsmith.tailwind")
 
 # Pin matches scripts/build-tailwind.sh and the Dockerfile build stage so every
 # sheet — committed, image-baked, and runtime-regenerated — comes from the same
@@ -47,7 +45,7 @@ APP_DIR = Path(__file__).resolve().parent.parent
 
 
 def _user_plugins_dir() -> Path | None:
-    raw = (getenv_compat("FEEDBACK_PLUGINS_DIR", "") or "").strip()
+    raw = os.environ.get("SLOPSMITH_PLUGINS_DIR", "").strip()
     if not raw:
         return None
     p = Path(raw)

lib/tones.py

@@ -1,13 +1,13 @@
 """Tone helpers for sloppak playback.
 
-A feedBack arrangement may carry a tone block — the initial tone name plus
+A slopsmith arrangement may carry a tone block — the initial tone name plus
 in-song tone switches — embedded inline in the arrangement JSON (see
 ``lib/song.py`` ``arrangement_to_wire`` / the ``tones`` wire key). This module
 turns that already-embedded block into the (base, changes) payload the highway
 WebSocket sends to the client.
 
 The proprietary-archive tone-extraction path (lifting tone definitions out of
-an unpacked encrypted archive) has been removed. FeedBack reads tones only
+an unpacked encrypted archive) has been removed. Slopsmith reads tones only
 from its own ``.sloppak`` / arrangement JSON; it never reads or decrypts
 proprietary archive formats.
 """
@@ -18,7 +18,7 @@ import logging
 import math
 import re
 
-log = logging.getLogger("feedBack.lib.tones")
+log = logging.getLogger("slopsmith.lib.tones")
 
 
 def tokens(s: str) -> set[str]:

lib/vocal_pitch.py

@@ -5,7 +5,7 @@ isolated vocals + per-syllable lyric timing (both produced by the
 WhisperX fallback or shipped in the source archive), the /pitch endpoint
 runs CREPE over the vocals stem and returns one MIDI note per supplied
 timing token. The result lands in `<sloppak>/vocal_pitch.json` in the
-shape the got-feedback/feedBack-plugin-lyrics-karaoke renderer
+shape the got-feedback/feedback-plugin-lyrics-karaoke renderer
 already consumes:
 
     {"version": 1, "notes": [{"t": float, "d": float, "midi": int}, ...]}
@@ -23,18 +23,18 @@ runs locally. Adding a local CREPE path here would mean pulling
 `crepe` + `tensorflow` as plugin deps (~500 MB+ on top of the
 existing torch/demucs/whisperx). Deferred until users hit the gap.
 If you need a local fallback today, install
-`got-feedback/feedBack-plugin-lyrics-karaoke` and let its local
+`got-feedback/feedback-plugin-lyrics-karaoke` and let its local
 pYIN run when the server isn't reachable.
 
 Cache key parity with stem_separation / lyric_transcription
 ───────────────────────────────────────────────────────────
 A `pitch_extraction` manifest block mirrors the shape introduced by
-feedBack#357: `{engine, model, version}`. Today engine is fixed at
+slopsmith#357: `{engine, model, version}`. Today engine is fixed at
 `"crepe"` (the server's choice) and model at `"v1"` (server doesn't
 yet expose the CREPE capacity dial it uses internally; this is the
 requested value, same caveat as `lyric_transcription.model`). The
 schema version is independent of the upstream CREPE version and bumps
-per feedBack's contract:
+per slopsmith's contract:
    * patch — metadata-only or implementation fixes
    * minor — backward-compatible additions
    * major — output shape / semantics changed; existing
@@ -50,7 +50,7 @@ import math
 from pathlib import Path
 from typing import Callable, Optional
 
-log = logging.getLogger("feedBack.lib.vocal_pitch")
+log = logging.getLogger("slopsmith.lib.vocal_pitch")
 
 ProgressCB = Optional[Callable[[float, str, str], None]]
 
@@ -72,7 +72,7 @@ def extract_pitch_remote(
 ) -> list[dict]:
     """POST the vocal stem + lyric timings to `{server_url}/pitch`.
 
-    `lyrics` is the same `[{t, d, w}, ...]` list feedBack writes to
+    `lyrics` is the same `[{t, d, w}, ...]` list slopsmith writes to
     `lyrics.json`. The endpoint only consumes `t` + `d` (it doesn't
     need the word text), but we pass the full payload through —
     slimmer to forward what we already have than to project.

lib/wem_decode.py

@@ -6,7 +6,7 @@ import logging
 import struct
 import os
 
-log = logging.getLogger("feedBack.lib.wem_decode")
+log = logging.getLogger("slopsmith.lib.wem_decode")
 
 
 def convert_wem_to_ogg(wem_path: str, output_path: str) -> bool:

main.py

@@ -1,4 +1,4 @@
-"""Programmatic entry point for the FeedBack server.
+"""Programmatic entry point for the Slopsmith server.
 
 Using ``uvicorn.run()`` with ``log_config=None`` prevents uvicorn from calling
 ``logging.config.dictConfig(LOGGING_CONFIG)`` during its startup sequence.

package-lock.json

@@ -1,11 +1,11 @@
 {
-  "name": "feedBack-browser-tests",
+  "name": "slopsmith-browser-tests",
   "version": "1.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "feedBack-browser-tests",
+      "name": "slopsmith-browser-tests",
       "version": "1.0.0",
       "license": "AGPL-3.0-only",
       "devDependencies": {

package.json

@@ -1,7 +1,7 @@
 {
-  "name": "feedBack-browser-tests",
+  "name": "slopsmith-browser-tests",
   "version": "1.0.0",
-  "description": "Browser tests for FeedBack keyboard shortcuts and JS plugin-API contract tests under tests/js/.",
+  "description": "Browser tests for Slopsmith keyboard shortcuts and JS plugin-API contract tests under tests/js/.",
   "license": "AGPL-3.0-only",
   "scripts": {
     "test": "playwright test",

plugins/__init__.py

@@ -15,7 +15,7 @@ from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, Response
 
 from safepath import safe_join
 
-log = logging.getLogger("feedBack.plugins")
+log = logging.getLogger("slopsmith.plugins")
 
 
 PLUGINS_DIR = Path(__file__).parent
@@ -43,7 +43,7 @@ PLUGINS_LOCK = threading.RLock()
 # registry mutation (the pending seed, _graduate, _mark_failed) re-checks it
 # under the lock before touching LOADED_PLUGINS / PENDING_PLUGINS. This keeps a
 # still-running loader from an EARLIER pass — e.g. a "reload plugins" action,
-# FEEDBACK_SYNC_STARTUP hot-reload, or test teardown re-invoking load_plugins()
+# SLOPSMITH_SYNC_STARTUP hot-reload, or test teardown re-invoking load_plugins()
 # while the first pass's background install thread is mid-flight — from
 # repopulating or duplicating entries after a NEWER pass has already cleared the
 # registries. Only the latest pass is allowed to publish.
@@ -238,7 +238,7 @@ def _normalize_manifest_sequence(value) -> list:
 
 _CAPABILITY_STANDARD = "capability-pipelines.v1"
 _VALID_CAPABILITY_ROLES = {
-    "owner", "provider", "observer", "requester", "transformer", "handler",
+    "owner", "coordinator", "provider", "observer", "requester", "transformer", "handler",
     "validator", "short-circuiter", "contributor",
 }
 _VALID_CAPABILITY_MODES = {"active", "optional", "legacy-shim", "disabled"}
@@ -512,7 +512,7 @@ def _capability_warnings(manifest: dict, plugin_id: str) -> tuple[dict, list[dic
         if isinstance(declaration.get("provider_policy"), dict):
             clean["provider_policy"] = declaration["provider_policy"]
         # Declarative per-instance control descriptors a consuming host renders
-        # generically (feedBack#849). Domain-agnostic: validated for any
+        # generically (slopsmith#849). Domain-agnostic: validated for any
         # capability here and surfaced via /api/plugins; each domain defines how
         # a value is applied (visualization is the first consumer).
         if clean_settings:
@@ -567,7 +567,7 @@ def _load_plugin_sibling(plugin_id: str, plugin_dir: Path, name: str):
     import precedence). Mirrors the routes-loading pattern in
     `load_plugins()` and shares its `sys.modules` cache, so two plugins
     that each ship `extractor.py` get distinct cached modules instead
-    of stomping each other through `sys.path`. See feedBack#33."""
+    of stomping each other through `sys.path`. See slopsmith#33."""
     if not isinstance(plugin_id, str) or not plugin_id:
         raise ValueError(
             f"load_sibling: plugin_id must be a non-empty string, got {plugin_id!r}"
@@ -613,7 +613,7 @@ def _load_plugin_sibling(plugin_id: str, plugin_dir: Path, name: str):
     #     sys.modules entry — same key load_sibling produces
     # `setdefault` is atomic under the GIL so two threads racing to
     # create the parent can't overwrite each other's registration.
-    # Spotted by codex/Copilot reviews on PRs for feedBack#33.
+    # Spotted by codex/Copilot reviews on PRs for slopsmith#33.
     import types
     new_parent = types.ModuleType(parent_name)
     new_parent.__path__ = [str(plugin_dir)]
@@ -641,14 +641,14 @@ def _warn_on_module_collisions(plugin_specs):
     """Scan top-level importable modules across all plugins about to
     be loaded. Print a warning for any module name shipped by 2+
     plugins, since bare `import <name>` from those plugins will hit
-    the sys.path-based cache and cross-load (feedBack#33).
+    the sys.path-based cache and cross-load (slopsmith#33).
 
     Both top-level `.py` files AND top-level packages (directories
     containing `__init__.py`) are scanned — the same collision
     pattern applies to either, e.g. one plugin's `extractor.py` vs
     another plugin's `extractor/__init__.py` both produce a shared
     `sys.modules['extractor']` entry. Spotted by codex review on
-    PR for feedBack#33.
+    PR for slopsmith#33.
 
     `routes.py` itself is excluded because the loader already
     namespaces it as `plugin_{id}_routes`. Top-level dunder files
@@ -663,7 +663,7 @@ def _warn_on_module_collisions(plugin_specs):
     # — that intra-plugin layout is supported by load_sibling
     # (package form wins, matching CPython precedence) and shouldn't
     # trip a cross-plugin collision warning. Spotted by codex review
-    # on PR for feedBack#33.
+    # on PR for slopsmith#33.
     by_name: dict[str, dict[str, set[str]]] = {}
     for plugin_id, plugin_dir in plugin_specs:
         try:
@@ -700,7 +700,7 @@ def _warn_on_module_collisions(plugin_specs):
         log.warning(
             "Module-name collision: %r (%s) is shipped by %d plugins (%s). "
             "Bare `import %s` may load the wrong file. "
-            "Migrate to context['load_sibling']('%s') — see CLAUDE.md (feedBack#33).",
+            "Migrate to context['load_sibling']('%s') — see CLAUDE.md (slopsmith#33).",
             name, kind_label, len(by_plugin), ids_quoted, name, name,
         )
 
@@ -745,7 +745,7 @@ def _is_valid_tour_manifest(val) -> bool:
 def _normalize_export_paths(settings_field, plugin_id: str) -> list[str]:
     """Validate and normalize a plugin's `settings.server_files` manifest
     list into clean POSIX-style relpaths suitable for the settings
-    export/import bundle (feedBack#113).
+    export/import bundle (slopsmith#113).
 
     Each entry must be a non-empty string with no absolute prefix and
     no `..` segment. A trailing `/` denotes a directory (recurse on
@@ -1118,7 +1118,7 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
 
     # Collect plugin directories — user plugins first so they override built-in
     plugin_dirs = []
-    user_plugins_dir = os.environ.get("FEEDBACK_PLUGINS_DIR") or os.environ.get("SLOPSMITH_PLUGINS_DIR")
+    user_plugins_dir = os.environ.get("SLOPSMITH_PLUGINS_DIR")
     if user_plugins_dir:
         user_path = Path(user_plugins_dir)
         if user_path.is_dir() and user_path != PLUGINS_DIR:
@@ -1179,7 +1179,7 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
         )
 
     # Two-pass discovery so we can warn about cross-plugin module-name
-    # collisions BEFORE any plugin's setup runs (feedBack#33). The
+    # collisions BEFORE any plugin's setup runs (slopsmith#33). The
     # first pass collects (plugin_id, plugin_dir, manifest) tuples in
     # load order; the second pass actually executes each plugin's
     # setup with a per-plugin context.
@@ -1231,7 +1231,7 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
                 kept_is_bundled = _is_bundled(kept[1], kept[2]) if kept else False
                 if this_is_bundled and not kept_is_bundled:
                     # The incoming copy is the canonical bundled plugin; the
-                    # already-kept copy is user-installed (FEEDBACK_PLUGINS_DIR
+                    # already-kept copy is user-installed (SLOPSMITH_PLUGINS_DIR
                     # or cloned directly into plugins/). Bundled always wins —
                     # evict the user copy and fall through to register the
                     # bundled version instead.
@@ -1330,18 +1330,6 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
         _category = manifest.get("category")
         if not isinstance(_category, str) or not _category:
             _category = None
-        # Settings-tab placement (tabbed settings page). When `settings` is a
-        # dict, an optional `category` field names which settings tab the
-        # plugin's panel mounts under (e.g. "graphics", "mic", "progression").
-        # Distinct from the top-level `category` above (which drives Pedalboard
-        # grouping) so the two don't collide. Absent/blank → None → the
-        # frontend falls back to the generic "Plugins" tab.
-        _settings_manifest = manifest.get("settings")
-        _settings_category = None
-        if isinstance(_settings_manifest, dict):
-            _sc = _settings_manifest.get("category")
-            if isinstance(_sc, str) and _sc:
-                _settings_category = _sc
         _icon = manifest.get("icon")
         if not isinstance(_icon, str) or not _icon:
             _icon = None
@@ -1350,13 +1338,6 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
                     _icon = "assets/thumb.png"
             except OSError:
                 _icon = None
-        # Immersive (full-screen) screen opt-in. A plugin that declares a
-        # top-level `"fullscreen": true` gets the whole content area when its
-        # screen is active: the v3 shell hides the topbar and collapses the
-        # sidebar to an icon rail (see static/v3/shell.js + v3.css). For
-        # DAW-style plugin UIs that need the viewport, not a scrolling content
-        # page. Strict `is True` so a stray truthy value can't silently opt in.
-        _fullscreen = manifest.get("fullscreen") is True
         return {
             "id": plugin_id,
             "name": manifest.get("name", plugin_id),
@@ -1374,10 +1355,6 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
             "has_screen": bool(manifest.get("screen")),
             "has_script": bool(manifest.get("script")),
             "has_settings": bool(manifest.get("settings")),
-            "settings_category": _settings_category,
-            # Drives the v3 shell's immersive (full-screen) mode for this
-            # plugin's screen. False unless the manifest declares it explicitly.
-            "fullscreen": _fullscreen,
             "has_tour": _is_valid_tour_manifest(manifest.get("tour")),
             # `styles` is an optional relpath (under the plugin's assets/) to a
             # compiled, preflight-off stylesheet the frontend injects as a
@@ -1560,7 +1537,7 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
             continue
 
         # Add plugin directory to sys.path so the plugin's bare
-        # `import sibling` keeps working during the feedBack#33
+        # `import sibling` keeps working during the slopsmith#33
         # transition. New plugins should prefer
         # `context['load_sibling']('sibling')` instead — see
         # CLAUDE.md / Plugin System / Backend routes.
@@ -1579,13 +1556,13 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
         # bijectively encoded by _safe_plugin_id_for_module_name:
         # `_` -> `_5f_`, `.` -> `_2e_`) so two plugins shipping the
         # same filename get distinct cached modules. See
-        # feedBack#33.
+        # slopsmith#33.
         plugin_context = dict(context)
         plugin_context["load_sibling"] = (
             lambda name, _pid=plugin_id, _pdir=plugin_dir:
                 _load_plugin_sibling(_pid, _pdir, name)
         )
-        plugin_context["log"] = logging.getLogger(f"feedBack.plugin.{plugin_id}")
+        plugin_context["log"] = logging.getLogger(f"slopsmith.plugin.{plugin_id}")
         if callable(plugin_context.get("register_library_provider")):
             _register_library_provider = plugin_context["register_library_provider"]
 
@@ -1732,9 +1709,9 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
             # Normalized list of relpaths under CONFIG_DIR that this
             # plugin opts in to settings export/import. Empty for
             # plugins that don't declare `settings.server_files`. See
-            # feedBack#113.
+            # slopsmith#113.
             "_export_paths": _normalize_export_paths(manifest.get("settings"), plugin_id),
-            # Diagnostics opt-in (feedBack#166): same allowlist semantics
+            # Diagnostics opt-in (slopsmith#166): same allowlist semantics
             # as `_export_paths` but for the troubleshooting bundle.
             "_diagnostics_paths": _normalize_diagnostics_paths(manifest.get("diagnostics"), plugin_id),
             "_diagnostics_callable_spec": _parse_diagnostics_callable(manifest.get("diagnostics"), plugin_id),
@@ -1823,7 +1800,7 @@ def load_plugins(app: FastAPI, context: dict, progress_cb=None, route_setup_fn=N
             lambda name, _pid=evicted_id, _pdir=ev_dir:
                 _load_plugin_sibling(_pid, _pdir, name)
         )
-        ev_context["log"] = logging.getLogger(f"feedBack.plugin.{evicted_id}")
+        ev_context["log"] = logging.getLogger(f"slopsmith.plugin.{evicted_id}")
         if callable(ev_context.get("register_library_provider")):
             _ev_register_library_provider = ev_context["register_library_provider"]
 
@@ -2076,7 +2053,7 @@ def register_plugin_api(app: FastAPI):
                 "category": p.get("category") if "category" in p else ((p.get("_manifest") or {}).get("category") or None),
                 "icon": p.get("icon") if "icon" in p else ((p.get("_manifest") or {}).get("icon") or None),
                 # `bundled` is reserved metadata flagging plugins that
-                # ship with the default container image (feedBack#160).
+                # ship with the default container image (slopsmith#160).
                 # Surfaced in /api/plugins so the plugin-list UI can
                 # render a "Bundled" badge (lock icon) next to the
                 # plugin name in the settings collapsible.
@@ -2090,11 +2067,6 @@ def register_plugin_api(app: FastAPI):
                 "has_screen": p["has_screen"],
                 "has_script": p["has_script"],
                 "has_settings": p["has_settings"],
-                # v3 immersive screen opt-in (full-screen plugin UI).
-                "fullscreen": p.get("fullscreen", False),
-                # Settings-tab placement; None when the manifest's `settings`
-                # is absent, a bare string, or omits `category`.
-                "settings_category": p.get("settings_category"),
                 "has_tour": p.get("has_tour", False),
                 # `.get()` fallbacks keep stubbed test entries (built without
                 # _nav_entry) working — styles is None when unset.
@@ -2143,8 +2115,6 @@ def register_plugin_api(app: FastAPI):
                 "has_screen": e.get("has_screen", False),
                 "has_script": e.get("has_script", False),
                 "has_settings": e.get("has_settings", False),
-                "settings_category": e.get("settings_category"),
-                "fullscreen": e.get("fullscreen", False),
                 "has_tour": e.get("has_tour", False),
                 "has_styles": e.get("has_styles", False),
                 "styles": e.get("styles"),

plugins/achievements/achievements.json

@@ -1,68 +0,0 @@
-{
-  "version": 1,
-  "global": [
-    {
-      "id": "first_steps",
-      "title": "First Steps",
-      "description": "Reach Mastery Rank 1 — finish onboarding.",
-      "category": "global",
-      "sourceId": "achievements",
-      "criterion": { "type": "mastery_rank", "tiers": [1] },
-      "tiers": [1]
-    },
-    {
-      "id": "ascendant",
-      "title": "Ascendant",
-      "description": "Climb the Mastery Rank ladder.",
-      "category": "global",
-      "sourceId": "achievements",
-      "criterion": { "type": "mastery_rank", "tiers": [10, 25, 50] },
-      "tiers": [10, 25, 50],
-      "tier_titles": ["Ascendant I", "Ascendant II", "Ascendant III"]
-    },
-    {
-      "id": "steady_hands",
-      "title": "Steady Hands",
-      "description": "Make a real advance on many separate days.",
-      "category": "global",
-      "sourceId": "achievements",
-      "criterion": { "type": "growth_streak_days", "tiers": [7, 30, 100] },
-      "tiers": [7, 30, 100],
-      "tier_titles": ["Steady Hands (7)", "Steady Hands (30)", "Steady Hands (100)"]
-    },
-    {
-      "id": "renaissance",
-      "title": "Renaissance",
-      "description": "Reach Level 10 across several distinct instrument paths.",
-      "category": "global",
-      "sourceId": "achievements",
-      "criterion": { "type": "paths_at_level", "level": 10, "tiers": [2, 3, 5] },
-      "tiers": [2, 3, 5],
-      "tier_titles": ["Renaissance (2)", "Renaissance (3)", "Renaissance (5)"]
-    }
-  ],
-  "per_instrument": [
-    {
-      "id": "path_rank",
-      "title": "{Inst} Mastery",
-      "description": "Climb the {Inst} path: Apprentice, Journeyman, Master.",
-      "sourceId": "achievements",
-      "criterion": { "type": "path_level", "tiers": [10, 25, "max"] },
-      "tier_titles": ["{Inst} Apprentice", "{Inst} Journeyman", "{Inst} Master"]
-    },
-    {
-      "id": "personal_best",
-      "title": "Personal Best ({Inst})",
-      "description": "Beat your own best accuracy on any {Inst} chart.",
-      "sourceId": "achievements",
-      "criterion": { "type": "personal_best" }
-    },
-    {
-      "id": "challenger",
-      "title": "Challenger ({Inst})",
-      "description": "Clear a full level-up challenge set on the {Inst} path.",
-      "sourceId": "achievements",
-      "criterion": { "type": "challenge_set_cleared" }
-    }
-  ]
-}

plugins/achievements/assets/achievements.css

@@ -1,84 +0,0 @@
-/* Achievements & Feats of Power — plugin styles (plain CSS, no Tailwind build;
- * P-II: plugins ship their own stylesheet for non-core classes). Mirrors the v3
- * dark surface tokens used across the Profile page. */
-
-/* Secondary category pill row inside the Achievements tab (lighter .fb-tab). */
-.fb-ach-pillrow {
-    display: flex;
-    flex-wrap: wrap;
-    gap: .4rem;
-    margin-bottom: 1rem;
-}
-.fb-ach-pill {
-    appearance: none;
-    background: rgba(30, 41, 59, .5);
-    border: 1px solid rgba(51, 65, 85, .6);
-    color: #94a3b8;
-    border-radius: 9999px;
-    padding: .35rem .75rem;
-    font-size: .8rem;
-    font-weight: 600;
-    cursor: pointer;
-    transition: color .15s, border-color .15s, background .15s;
-}
-.fb-ach-pill:hover { color: #e2e8f0; border-color: rgba(14, 165, 233, .4); }
-.fb-ach-pill.active { color: #f8fafc; background: rgba(14, 165, 233, .15); border-color: #0ea5e9; }
-.fb-ach-pill-badge {
-    font-size: .7rem;
-    font-weight: 700;
-    color: #64748b;
-    margin-left: .15rem;
-}
-.fb-ach-pill.active .fb-ach-pill-badge { color: #7dd3fc; }
-
-/* Catalogue list. */
-.fb-ach-list { display: flex; flex-direction: column; gap: .5rem; }
-.fb-ach-item {
-    display: flex;
-    align-items: flex-start;
-    gap: .85rem;
-    padding: .75rem .9rem;
-    border-radius: .6rem;
-    border: 1px solid rgba(51, 65, 85, .5);
-    background: rgba(30, 41, 59, .35);
-}
-.fb-ach-item.locked { opacity: .45; filter: grayscale(.6); }
-.fb-ach-item.earned { border-color: rgba(14, 165, 233, .35); background: rgba(14, 165, 233, .06); }
-.fb-ach-item-icon { font-size: 1.4rem; line-height: 1.6rem; flex: 0 0 auto; }
-.fb-ach-item-body { min-width: 0; }
-.fb-ach-item-title {
-    font-size: .9rem;
-    font-weight: 700;
-    color: #f1f5f9;
-    display: flex;
-    align-items: center;
-    gap: .4rem;
-}
-.fb-ach-tier {
-    font-size: .65rem;
-    text-transform: uppercase;
-    letter-spacing: .04em;
-    font-weight: 700;
-    color: #7dd3fc;
-    border: 1px solid rgba(125, 211, 252, .35);
-    border-radius: 9999px;
-    padding: .05rem .4rem;
-}
-.fb-ach-item-desc { font-size: .78rem; color: #94a3b8; margin-top: .15rem; }
-
-/* Feats of Power trophy shelf (profile main page). */
-.fb-feat-shelf {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
-    gap: .75rem;
-}
-.fb-feat-card {
-    text-align: center;
-    padding: 1rem .75rem;
-    border-radius: .7rem;
-    border: 1px solid rgba(234, 179, 8, .35);
-    background: linear-gradient(180deg, rgba(234, 179, 8, .1), rgba(30, 41, 59, .3));
-}
-.fb-feat-icon { font-size: 1.9rem; }
-.fb-feat-title { font-size: .85rem; font-weight: 800; color: #fde68a; margin-top: .3rem; }
-.fb-feat-desc { font-size: .72rem; color: #cbd5e1; margin-top: .25rem; }

plugins/achievements/engine.py

@@ -1,191 +0,0 @@
-"""Achievements & Feats of Power — pure evaluation helpers.
-
-This module holds the side-effect-free core of the engine so it is unit
-testable (constitution P-V): no IO, no SQLite, no clock. `routes.py` owns the
-storage/HTTP shell and calls into these functions.
-
-**Integration law (structural):** Feats are evaluated from *activity counters*
-only (`evaluate_feats` / `apply_activity`); competency Achievements are recorded
-from *competency events* the source reports (`report-unlock`). Nothing here ever
-converts an activity count into a competency unlock or vice versa.
-"""
-
-from __future__ import annotations
-
-# Counter keys the activity model owns. `*_max` keys take the running maximum;
-# everything else is a cumulative running total. Kept here (not in routes) so a
-# test can assert the contract without standing up a DB.
-MAX_COUNTERS = frozenset({"notes_session_max", "streak_insong_max", "chart_encore_max"})
-
-
-def tier_index_for(tiers, value):
-    """Highest 0-based tier index whose threshold is met by ``value``.
-
-    Returns -1 when no tier is reached. Tiers are assumed ascending; we scan
-    all of them rather than short-circuit so an out-of-order catalogue still
-    resolves to the largest satisfied tier.
-    """
-    idx = -1
-    for i, threshold in enumerate(tiers or []):
-        try:
-            if value >= threshold:
-                idx = i
-        except TypeError:
-            continue
-    return idx
-
-
-def feat_counter_value(feat, counters):
-    """Activity-counter value backing a Feat definition (0 when absent)."""
-    key = feat.get("counter")
-    if not key:
-        return 0
-    try:
-        return int(counters.get(key, 0) or 0)
-    except (TypeError, ValueError):
-        return 0
-
-
-def evaluate_feats(feat_defs, counters):
-    """Map ``feat_id -> highest reached tier index`` for all satisfied Feats.
-
-    A Feat with no tiers, or whose counter hasn't reached tier 0, is omitted.
-    Pure: takes the current counters snapshot, returns a plain dict.
-    """
-    out = {}
-    for feat in feat_defs or []:
-        fid = feat.get("id")
-        if not fid:
-            continue
-        tiers = feat.get("tiers") or []
-        if not tiers:
-            continue
-        ti = tier_index_for(tiers, feat_counter_value(feat, counters))
-        if ti >= 0:
-            out[fid] = ti
-    return out
-
-
-def apply_activity(counters, delta):
-    """Return a NEW counters dict after folding in one activity ``delta``.
-
-    Cumulative keys add; ``*_max`` keys keep the running maximum. The caller
-    (routes.py) is responsible for the only stateful bit — the per-chart play
-    count — and passes the post-increment value as ``delta['chart_play_count']``
-    so this function stays pure.
-
-    Recognised delta fields (all optional, default 0):
-      notes            -> notes_total            (+=)
-      song_done        -> songs_done             (+=)
-      seconds          -> time_total_seconds     (+=)
-      session_notes    -> notes_session_max      (max)
-      in_song_streak   -> streak_insong_max      (max)
-      chart_play_count -> chart_encore_max       (max)
-    """
-    out = dict(counters or {})
-
-    def _cur(key):
-        try:
-            return int(out.get(key, 0) or 0)
-        except (TypeError, ValueError):
-            return 0
-
-    def _int(v):
-        try:
-            return int(v or 0)
-        except (TypeError, ValueError):
-            return 0
-
-    out["notes_total"] = _cur("notes_total") + _int(delta.get("notes"))
-    out["songs_done"] = _cur("songs_done") + _int(delta.get("song_done"))
-    out["time_total_seconds"] = _cur("time_total_seconds") + _int(delta.get("seconds"))
-    out["notes_session_max"] = max(_cur("notes_session_max"), _int(delta.get("session_notes")))
-    out["streak_insong_max"] = max(_cur("streak_insong_max"), _int(delta.get("in_song_streak")))
-    if delta.get("chart_play_count") is not None:
-        out["chart_encore_max"] = max(_cur("chart_encore_max"), _int(delta.get("chart_play_count")))
-    return out
-
-
-def consecutive_run_length(dates):
-    """Longest run of consecutive calendar dates in ``dates`` (ISO 'YYYY-MM-DD').
-
-    Used by the `secret_witching` Feat (practise in the 2–5am window on N
-    consecutive nights). Pure date arithmetic so it's unit-testable; routes.py
-    feeds it the distinct night-dates recorded in `comp_ledger`.
-    """
-    from datetime import date
-
-    parsed = []
-    for d in dates or []:
-        try:
-            y, m, dd = (int(x) for x in str(d).split("-"))
-            parsed.append(date(y, m, dd))
-        except (ValueError, TypeError):
-            continue
-    if not parsed:
-        return 0
-    parsed = sorted(set(parsed))
-    best = run = 1
-    for prev, cur in zip(parsed, parsed[1:]):
-        if (cur - prev).days == 1:
-            run += 1
-            best = max(best, run)
-        else:
-            run = 1
-    return best
-
-
-# ── Data-minimization contract (binding, code-enforced) ──────────────────────
-# The wall payload key-set is frozen here and asserted by a unit test. The
-# serializer below is the ONLY way outbound data is built — never dict(row) or
-# **model — so a stray field cannot leak. Adding a key makes the test go red.
-WALL_PAYLOAD_KEYS = ("display_name", "player_hash", "achievement_id", "unlocked_at")
-
-
-def build_wall_payload(display_name, player_hash, achievement_id, unlocked_at):
-    """Build the EXACT four-field wall payload. ``achievement_id`` must always be
-    a Feat id (the caller only ever invokes this for Feat unlocks — competency
-    never syncs). Explicit literal dict on purpose; do not refactor into a
-    row/model splat."""
-    return {
-        "display_name": display_name,
-        "player_hash": player_hash,
-        "achievement_id": achievement_id,
-        "unlocked_at": unlocked_at,
-    }
-
-
-def drain_decision(status):
-    """Dead-letter state machine for one wall-sync attempt (pure).
-
-    ``status`` is the HTTP status code, or ``None`` for a network error.
-    Returns one of:
-      'ack'   → server accepted; delete the row.
-      'retry' → keep it pending (network error, 429 backoff, or 5xx).
-      'dead'  → any other 4xx; move to dead_letter (diagnosable/replayable).
-    A row is NEVER silently dropped — it leaves the queue only on 'ack' (or a
-    user opt-out wiping it).
-    """
-    if status is None:
-        return "retry"
-    if 200 <= status < 300:
-        return "ack"
-    if status == 429:
-        return "retry"
-    if 400 <= status < 500:
-        return "dead"
-    return "retry"  # 5xx — transient server-side, try again later
-
-
-def diff_unlocks(prev_tiers, new_tiers):
-    """Feat ids whose tier advanced (incl. first unlock).
-
-    ``prev_tiers`` / ``new_tiers`` are ``feat_id -> tier_index`` maps as
-    returned by :func:`evaluate_feats`. Returns the ids that are newly present
-    or moved to a higher tier — i.e. the Feats to record + announce this round.
-    """
-    out = []
-    for fid, tier in (new_tiers or {}).items():
-        if tier > prev_tiers.get(fid, -1):
-            out.append(fid)
-    return out

plugins/achievements/feats.json

@@ -1,101 +0,0 @@
-{
-  "version": 1,
-  "feats": [
-    {
-      "id": "notes_total",
-      "title": "Note Hunter",
-      "description": "Hit a colossal number of notes across all your practice.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": false,
-      "needs_notedetect": true,
-      "counter": "notes_total",
-      "tiers": [100000, 1000000, 10000000],
-      "tier_titles": ["Note Hunter", "Million-Note Maestro", "Ten-Million-Note Titan"]
-    },
-    {
-      "id": "notes_session",
-      "title": "Marathon",
-      "description": "Hit 25,000 notes in a single sitting.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": false,
-      "needs_notedetect": true,
-      "counter": "notes_session_max",
-      "tiers": [25000],
-      "tier_titles": ["Marathon"]
-    },
-    {
-      "id": "streak_insong",
-      "title": "Untouchable",
-      "description": "Land a huge run of consecutive in-song hits with no miss.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": false,
-      "needs_notedetect": true,
-      "counter": "streak_insong_max",
-      "tiers": [1000, 5000],
-      "tier_titles": ["Untouchable", "Truly Untouchable"]
-    },
-    {
-      "id": "songs_done",
-      "title": "Road Warrior",
-      "description": "Finish a mountain of songs.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": false,
-      "needs_notedetect": false,
-      "counter": "songs_done",
-      "tiers": [1000, 5000],
-      "tier_titles": ["Road Warrior", "Road Legend"]
-    },
-    {
-      "id": "time_total",
-      "title": "Time Served",
-      "description": "Pour hundreds of hours into practice.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": false,
-      "needs_notedetect": false,
-      "counter": "time_total_seconds",
-      "tiers": [1800000, 7200000],
-      "tier_titles": ["Time Served (500h)", "Time Served (2,000h)"]
-    },
-    {
-      "id": "chart_encore",
-      "title": "Encore",
-      "description": "Play the same chart again and again and again.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": false,
-      "needs_notedetect": false,
-      "counter": "chart_encore_max",
-      "tiers": [100, 500],
-      "tier_titles": ["Encore", "Standing Ovation"]
-    },
-    {
-      "id": "secret_witching",
-      "title": "The Witching Hour",
-      "description": "Practise in the dead of night, seven nights running.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": true,
-      "needs_notedetect": false,
-      "counter": "witching_nights_run",
-      "tiers": [7],
-      "tier_titles": ["The Witching Hour"]
-    },
-    {
-      "id": "secret_combo",
-      "title": "Hidden Track",
-      "description": "You found the hidden track.",
-      "category": "global",
-      "sourceId": "achievements",
-      "secret": true,
-      "needs_notedetect": false,
-      "counter": null,
-      "tiers": [],
-      "tier_titles": ["Hidden Track"]
-    }
-  ]
-}

plugins/achievements/plugin.json

@@ -1,18 +0,0 @@
-{
-  "id": "achievements",
-  "name": "Achievements",
-  "version": "0.1.0",
-  "bundled": true,
-  "private": false,
-  "description": "Achievements & Feats of Power — skill milestones on your Profile, plus rare activity Feats.",
-  "script": "screen.js",
-  "styles": "assets/achievements.css",
-  "settings": {
-    "html": "settings.html",
-    "category": "system",
-    "server_files": [
-      "achievements/"
-    ]
-  },
-  "routes": "routes.py"
-}

plugins/achievements/routes.py

@@ -1,585 +0,0 @@
-"""Achievements & Feats of Power — local engine (offline).
-
-State lives under ``<config_dir>/achievements/``:
-  - ``achievements.db``  SQLite — unlocks, activity counters, derived ledger,
-                         and the (PR3) wall sync queue.
-
-Two surfaces, one engine, kept structurally apart (the **integration law**):
-  * **Feats of Power** — activity/volume. The engine OWNS raw activity counters
-    (`counters`), evaluates Feat thresholds, and records Feat unlocks. Feats are
-    the only thing that ever syncs to the public wall.
-  * **Achievements** — demonstrated competency. The engine RECORDS unlocks the
-    source reports (`report-unlock`); it never re-derives them from activity.
-    A baseline catalogue ships here and is driven by the built-in progression
-    system; richer items are contributed by source plugins at runtime.
-
-Endpoints (all under /api/plugins/achievements/):
-  POST /activity        bump activity counters, eval Feats, return newly-unlocked
-  POST /report-unlock   idempotent upsert of a competency/feat unlock
-  POST /report-criterion record a (criterion_id, token) pair → distinct count
-  GET  /catalog         baseline competency defs + earned state
-  GET  /earned          all earned items (id, cls, category, tier, at)
-  GET  /feats           earned Feats (for the profile trophy shelf)
-  POST /remove-me       wipe synced state (full wall-removal lands in PR2/PR3)
-
-Pure threshold/criterion math lives in the sibling ``engine.py`` (P-V testable);
-this module is the SQLite + HTTP shell.
-"""
-
-import hashlib
-import json
-import logging
-import os
-import sqlite3
-import threading
-import time
-from pathlib import Path
-
-from pydantic import BaseModel, Field
-
-_lock = threading.Lock()
-_state = {
-    "db_path": None,
-    "dir": None,            # plugin directory (for catalog JSON)
-    "config_dir": None,     # CONFIG_DIR (for reading the opt-in setting)
-    "meta_db": None,        # MetadataDB (for the profile identity: name + hash)
-    "log": logging.getLogger("feedBack.plugin.achievements"),
-    "engine": None,         # sibling engine.py module (pure helpers)
-    "feat_defs": [],        # parsed feats.json -> list of feat defs
-    "baseline": {},         # parsed achievements.json
-}
-
-
-# ── SQLite ──────────────────────────────────────────────────────────────────
-
-def _conn():
-    conn = sqlite3.connect(_state["db_path"], timeout=5)
-    conn.row_factory = sqlite3.Row
-    conn.execute("PRAGMA journal_mode=WAL")
-    return conn
-
-
-def _init_db():
-    conn = _conn()
-    try:
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS unlocks (
-                achievement_id TEXT PRIMARY KEY,
-                cls            TEXT NOT NULL,          -- 'competency' | 'feat'
-                disp_category  TEXT,                   -- global/guitar/bass/...
-                source_id      TEXT,
-                tier           INTEGER NOT NULL DEFAULT 0,
-                unlocked_at    TEXT,
-                synced         INTEGER NOT NULL DEFAULT 0
-            )
-            """
-        )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS counters (
-                key   TEXT PRIMARY KEY,
-                value INTEGER NOT NULL DEFAULT 0
-            )
-            """
-        )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS comp_ledger (
-                criterion_id TEXT NOT NULL,
-                token        TEXT NOT NULL,
-                PRIMARY KEY (criterion_id, token)
-            )
-            """
-        )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS sync_queue (
-                id      INTEGER PRIMARY KEY AUTOINCREMENT,
-                kind    TEXT NOT NULL,                 -- 'unlock' | 'remove'
-                payload TEXT NOT NULL,
-                state   TEXT NOT NULL DEFAULT 'pending' -- 'pending' | 'dead_letter'
-            )
-            """
-        )
-        conn.commit()
-    finally:
-        conn.close()
-
-
-def _now_iso():
-    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-
-
-def _opted_in():
-    """True only when the user has opted in (core setting ``achievements_enabled``).
-
-    Read straight from CONFIG_DIR/config.json — the single source of truth the
-    /api/settings endpoint persists. Default OFF on any read failure: nothing
-    leaves the device unless explicitly enabled.
-    """
-    try:
-        cfg_path = Path(_state["config_dir"]) / "config.json"
-        cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
-        return bool(cfg.get("achievements_enabled") is True)
-    except (OSError, ValueError, TypeError):
-        return False
-
-
-def _identity():
-    """(display_name, player_hash) from the profile, or (None, None).
-
-    Reused as the wall identity (server.py's documented player_hash). Sync is
-    skipped entirely when either is missing.
-    """
-    db = _state["meta_db"]
-    if db is None or not hasattr(db, "get_profile"):
-        return None, None
-    try:
-        prof = db.get_profile() or {}
-        return (prof.get("display_name") or None), (prof.get("player_hash") or None)
-    except Exception:  # noqa: BLE001 — identity is best-effort; never break a request
-        return None, None
-
-
-def _enqueue_feat_sync(conn, feat_id, unlocked_at):
-    """Enqueue a wall-sync POST for a Feat unlock — opt-in gated, identity gated.
-
-    Builds the outbound payload through the SINGLE code-gated serializer
-    (engine.build_wall_payload, exactly four fields). Competency unlocks never
-    reach this path (integration law + data-minimization contract). The drain
-    worker (PR3) POSTs the queued rows; here we only persist intent.
-    """
-    if not _opted_in():
-        return False
-    display_name, player_hash = _identity()
-    if not display_name or not player_hash:
-        return False
-    payload = _state["engine"].build_wall_payload(display_name, player_hash, feat_id, unlocked_at)
-    conn.execute(
-        "INSERT INTO sync_queue(kind, payload, state) VALUES ('unlock', ?, 'pending')",
-        (json.dumps(payload),),
-    )
-    return True
-
-
-# ── Wall sync — background drain worker (dead-letter, never drop) ─────────────
-# Idle unless a wall URL is configured. POSTs pending rows to the hosted
-# feedback-achievements service; the decision state machine
-# (engine.drain_decision) is pure + tested. A row leaves the queue only on a
-# server ack (or a user opt-out wiping it) — never silently dropped.
-
-# Canonical hosted Feats wall (the got-feedback service). Used by default so the
-# drain worker targets it out of the box; override via env for self-hosting or a
-# staging wall. Nothing is ever sent unless the user opted in AND has an identity
-# (see _enqueue_feat_sync), so a default URL does not publish anything on its own.
-_DEFAULT_WALL_URL = "https://feedback-achievements.onrender.com"
-_WALL_URL = (os.environ.get("FEEDBACK_ACHIEVEMENTS_WALL_URL")
-             or os.environ.get("SLOPSMITH_ACHIEVEMENTS_WALL_URL")
-             or _DEFAULT_WALL_URL).rstrip("/")
-_WALL_TOKEN = os.environ.get("FEEDBACK_ACHIEVEMENTS_CLIENT_TOKEN", "fb-wall-v1")
-_DRAIN_INTERVAL_S = int(os.environ.get("FEEDBACK_ACHIEVEMENTS_DRAIN_INTERVAL", "30"))
-_drain_started = False
-
-
-def _post_to_wall(kind, payload):
-    """POST one queued item; return the HTTP status code, or None on a network
-    error. Mirrors the lib/lyrics_transcribe outbound pattern (explicit timeout,
-    no raise on non-2xx — the caller's state machine decides)."""
-    import requests  # local import: only needed when a wall is configured
-
-    path = "/api/unlock" if kind == "unlock" else "/api/remove"
-    try:
-        resp = requests.post(
-            _WALL_URL + path, json=payload,
-            headers={"X-Client-Token": _WALL_TOKEN, "Content-Type": "application/json"},
-            timeout=10,
-        )
-        return resp.status_code
-    except requests.RequestException:
-        return None
-
-
-def _drain_once(post_fn=None):
-    """Process all pending queue rows once. ``post_fn(kind, payload) -> status``
-    is injectable for tests; defaults to the real wall POST."""
-    post_fn = post_fn or _post_to_wall
-    engine = _state["engine"]
-    with _lock:
-        conn = _conn()
-        try:
-            rows = conn.execute(
-                "SELECT id, kind, payload FROM sync_queue WHERE state='pending'").fetchall()
-        finally:
-            conn.close()
-    for row in rows:
-        try:
-            payload = json.loads(row["payload"]) if row["payload"] else {}
-        except ValueError:
-            payload = {}
-        status = post_fn(row["kind"], payload)
-        action = engine.drain_decision(status)
-        with _lock:
-            conn = _conn()
-            try:
-                if action == "ack":
-                    conn.execute("DELETE FROM sync_queue WHERE id=?", (row["id"],))
-                elif action == "dead":
-                    conn.execute("UPDATE sync_queue SET state='dead_letter' WHERE id=?", (row["id"],))
-                # 'retry' → leave it pending for the next pass
-                conn.commit()
-            finally:
-                conn.close()
-
-
-def _drain_loop():
-    while True:
-        try:
-            _drain_once()
-        except Exception as e:  # noqa: BLE001 — a worker crash must not kill the thread
-            _state["log"].warning("achievements wall drain error: %s", e)
-        time.sleep(_DRAIN_INTERVAL_S)
-
-
-def _maybe_start_drain():
-    global _drain_started
-    if _drain_started or not _WALL_URL:
-        return
-    _drain_started = True
-    threading.Thread(target=_drain_loop, name="ach-wall-drain", daemon=True).start()
-    _state["log"].info("achievements wall drain worker started → %s", _WALL_URL)
-
-
-def _chart_key(chart):
-    """Stable per-chart counter key — a sha1 digest of the chart id. NOT the
-    builtin hash(), whose str hashing is salted per process (PYTHONHASHSEED), so
-    the same chart would land on a different counter after every restart and the
-    Encore Feat could never accumulate across sessions."""
-    return "chart_plays:" + hashlib.sha1(str(chart).encode("utf-8")).hexdigest()[:16]
-
-
-def _read_counters(conn):
-    # Excludes the per-chart `chart_plays:*` rows: they are bumped + read
-    # individually via _bump_counter and would otherwise make this aggregate
-    # round-trip O(distinct charts played) on every activity POST.
-    return {
-        row["key"]: int(row["value"])
-        for row in conn.execute("SELECT key, value FROM counters WHERE key NOT LIKE 'chart_plays:%'")
-    }
-
-
-def _write_counters(conn, counters):
-    for key, value in counters.items():
-        conn.execute(
-            "INSERT INTO counters(key, value) VALUES (?, ?) "
-            "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
-            (key, int(value)),
-        )
-
-
-def _bump_counter(conn, key, delta):
-    """Increment a counter and return the new value (used for per-chart plays)."""
-    conn.execute(
-        "INSERT INTO counters(key, value) VALUES (?, ?) "
-        "ON CONFLICT(key) DO UPDATE SET value=value+excluded.value",
-        (key, int(delta)),
-    )
-    row = conn.execute("SELECT value FROM counters WHERE key=?", (key,)).fetchone()
-    return int(row["value"]) if row else int(delta)
-
-
-def _earned_feat_tiers(conn):
-    return {
-        row["achievement_id"]: int(row["tier"])
-        for row in conn.execute("SELECT achievement_id, tier FROM unlocks WHERE cls='feat'")
-    }
-
-
-def _record_unlock(conn, ach_id, cls, disp_category, source_id, tier, at):
-    """Idempotent upsert; only advances the tier upward. Returns True if changed."""
-    row = conn.execute("SELECT tier FROM unlocks WHERE achievement_id=?", (ach_id,)).fetchone()
-    if row is not None and int(row["tier"]) >= int(tier):
-        return False
-    conn.execute(
-        """
-        INSERT INTO unlocks(achievement_id, cls, disp_category, source_id, tier, unlocked_at, synced)
-        VALUES (?, ?, ?, ?, ?, ?, 0)
-        ON CONFLICT(achievement_id) DO UPDATE SET
-            tier=excluded.tier,
-            cls=excluded.cls,
-            disp_category=COALESCE(excluded.disp_category, unlocks.disp_category),
-            source_id=COALESCE(excluded.source_id, unlocks.source_id)
-        """,
-        (ach_id, cls, disp_category, source_id, int(tier), at or _now_iso()),
-    )
-    return True
-
-
-# ── Catalog loading ─────────────────────────────────────────────────────────
-
-def _feat_by_id(fid):
-    for f in _state["feat_defs"]:
-        if f.get("id") == fid:
-            return f
-    return None
-
-
-def _load_catalogs():
-    base = Path(_state["dir"])
-    try:
-        feats = json.loads((base / "feats.json").read_text(encoding="utf-8"))
-        _state["feat_defs"] = feats.get("feats", []) if isinstance(feats, dict) else []
-    except (OSError, ValueError) as e:
-        _state["log"].warning("achievements: could not load feats.json: %s", e)
-        _state["feat_defs"] = []
-    try:
-        _state["baseline"] = json.loads((base / "achievements.json").read_text(encoding="utf-8"))
-    except (OSError, ValueError) as e:
-        _state["log"].warning("achievements: could not load achievements.json: %s", e)
-        _state["baseline"] = {}
-
-
-# ── Request models ──────────────────────────────────────────────────────────
-
-class ActivityIn(BaseModel):
-    notes:          int = Field(ge=0, default=0)
-    session_notes:  int = Field(ge=0, default=0)
-    in_song_streak: int = Field(ge=0, default=0)
-    song_done:      int = Field(ge=0, default=0)
-    seconds:        int = Field(ge=0, default=0)
-    chart:          str | None = None
-    night_session:  bool = False
-    night_date:     str | None = None     # 'YYYY-MM-DD', frontend supplies (no server clock)
-
-
-class UnlockIn(BaseModel):
-    id:        str
-    kind:      str = "achievement"        # 'achievement' | 'feat'
-    category:  str | None = None          # display category (global/guitar/...)
-    sourceId:  str | None = None
-    tier:      int = Field(ge=0, default=0)
-    at:        str | None = None
-
-
-class CriterionIn(BaseModel):
-    criterion_id: str
-    token:        str
-
-
-# ── FastAPI wiring ──────────────────────────────────────────────────────────
-
-def setup(app, context):
-    config_dir = context["config_dir"]
-    base = Path(config_dir) / "achievements"
-    base.mkdir(parents=True, exist_ok=True)
-    _state["db_path"] = str(base / "achievements.db")
-    _state["dir"] = str(Path(__file__).resolve().parent)
-    _state["config_dir"] = str(config_dir)
-    _state["meta_db"] = context.get("meta_db")
-    _state["log"] = context.get("log") or _state["log"]
-    # Pure helpers via the per-plugin sibling loader (constitution P-III), with a
-    # plain-import fallback for pytest / standalone use.
-    load_sibling = context.get("load_sibling")
-    try:
-        _state["engine"] = load_sibling("engine") if load_sibling else __import__("engine")
-    except Exception:  # noqa: BLE001 — last-ditch, keep the plugin alive
-        import importlib.util
-        spec = importlib.util.spec_from_file_location(
-            "achievements_engine", str(Path(__file__).resolve().parent / "engine.py"))
-        mod = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-        _state["engine"] = mod
-    _init_db()
-    _load_catalogs()
-    log = _state["log"]
-
-    @app.post("/api/plugins/achievements/activity")
-    def post_activity(body: ActivityIn):
-        engine = _state["engine"]
-        with _lock:
-            conn = _conn()
-            try:
-                # Per-chart play count is the only directly-stateful bit; bump it
-                # first (stable key) so apply_activity() just takes the new max.
-                chart_play_count = None
-                if body.song_done and body.chart:
-                    chart_play_count = _bump_counter(conn, _chart_key(body.chart), 1)
-                # Night-window ledger → consecutive-night run. Computed here but
-                # NOT written before the prev snapshot: it is folded into the delta
-                # below so prev_tiers reflects the OLD run and new_tiers the new one
-                # (the same asymmetry chart_encore relies on). Pre-writing it would
-                # make prev already satisfy the Feat, so diff_unlocks would never
-                # see the freshly-earned witching unlock.
-                witching_run = None
-                if body.night_session and body.night_date:
-                    conn.execute(
-                        "INSERT OR IGNORE INTO comp_ledger(criterion_id, token) VALUES ('witching', ?)",
-                        (body.night_date,),
-                    )
-                    nights = [r["token"] for r in conn.execute(
-                        "SELECT token FROM comp_ledger WHERE criterion_id='witching'")]
-                    witching_run = engine.consecutive_run_length(nights)
-
-                counters = _read_counters(conn)
-                prev_tiers = engine.evaluate_feats(_state["feat_defs"], counters)
-                new_counters = engine.apply_activity(counters, {
-                    "notes": body.notes,
-                    "session_notes": body.session_notes,
-                    "in_song_streak": body.in_song_streak,
-                    "song_done": body.song_done,
-                    "seconds": body.seconds,
-                    "chart_play_count": chart_play_count,
-                })
-                if witching_run is not None:
-                    new_counters["witching_nights_run"] = max(
-                        int(new_counters.get("witching_nights_run", 0) or 0), witching_run)
-                _write_counters(conn, new_counters)
-                new_tiers = engine.evaluate_feats(_state["feat_defs"], new_counters)
-                fresh = engine.diff_unlocks(prev_tiers, new_tiers)
-                unlocked = []
-                for fid in fresh:
-                    f = _feat_by_id(fid) or {}
-                    tier = new_tiers[fid]
-                    at = _now_iso()
-                    if _record_unlock(conn, fid, "feat", f.get("category"), f.get("sourceId"), tier, at):
-                        _enqueue_feat_sync(conn, fid, at)
-                        unlocked.append(_feat_payload(fid, f, tier))
-                conn.commit()
-                return {"ok": True, "unlocked": unlocked, "counters": new_counters}
-            finally:
-                conn.close()
-
-    @app.post("/api/plugins/achievements/report-unlock")
-    def post_report_unlock(body: UnlockIn):
-        cls = "feat" if body.kind == "feat" else "competency"
-        at = body.at or _now_iso()
-        with _lock:
-            conn = _conn()
-            try:
-                changed = _record_unlock(
-                    conn, body.id, cls, body.category, body.sourceId, body.tier, at)
-                # Only Feats sync; competency never enqueues (integration law +
-                # data-minimization contract).
-                if changed and cls == "feat":
-                    _enqueue_feat_sync(conn, body.id, at)
-                conn.commit()
-                return {"ok": True, "changed": changed, "id": body.id, "tier": body.tier}
-            finally:
-                conn.close()
-
-    @app.post("/api/plugins/achievements/report-criterion")
-    def post_report_criterion(body: CriterionIn):
-        """Record a distinct (criterion_id, token); return the distinct count.
-
-        Lets a baseline subscriber aggregate multi-event criteria (e.g. the set
-        of distinct days with a real advance → `steady_hands`) without us
-        re-deriving competency from activity. Bookkeeping over events only.
-        """
-        with _lock:
-            conn = _conn()
-            try:
-                conn.execute(
-                    "INSERT OR IGNORE INTO comp_ledger(criterion_id, token) VALUES (?, ?)",
-                    (body.criterion_id, body.token),
-                )
-                row = conn.execute(
-                    "SELECT COUNT(*) AS n FROM comp_ledger WHERE criterion_id=?",
-                    (body.criterion_id,),
-                ).fetchone()
-                conn.commit()
-                return {"ok": True, "count": int(row["n"]) if row else 0}
-            finally:
-                conn.close()
-
-    @app.get("/api/plugins/achievements/catalog")
-    def get_catalog():
-        with _lock:
-            conn = _conn()
-            try:
-                earned = _earned_map(conn)
-            finally:
-                conn.close()
-        return {"baseline": _state["baseline"], "earned": earned}
-
-    @app.get("/api/plugins/achievements/earned")
-    def get_earned():
-        with _lock:
-            conn = _conn()
-            try:
-                return {"earned": list(_earned_map(conn).values())}
-            finally:
-                conn.close()
-
-    @app.get("/api/plugins/achievements/feats")
-    def get_feats():
-        with _lock:
-            conn = _conn()
-            try:
-                rows = conn.execute(
-                    "SELECT achievement_id, tier, unlocked_at FROM unlocks WHERE cls='feat'"
-                ).fetchall()
-            finally:
-                conn.close()
-        out = []
-        for row in rows:
-            fid = row["achievement_id"]
-            f = _feat_by_id(fid) or {}
-            payload = _feat_payload(fid, f, int(row["tier"]))
-            payload["unlocked_at"] = row["unlocked_at"]
-            out.append(payload)
-        return {"feats": out}
-
-    @app.post("/api/plugins/achievements/remove-me")
-    def post_remove_me():
-        # Local removal works offline: drop the synced flag so nothing re-syncs,
-        # and enqueue a wall removal (drained in PR3). The wall identity
-        # (player_hash) is resolved server-side at drain time, not stored here.
-        _, player_hash = _identity()
-        with _lock:
-            conn = _conn()
-            try:
-                conn.execute("UPDATE unlocks SET synced=0 WHERE cls='feat'")
-                # Enqueue a wall removal only when we have an identity to key it
-                # by; the drain worker (below) POSTs it. Idempotent server-side.
-                if player_hash:
-                    conn.execute(
-                        "INSERT INTO sync_queue(kind, payload, state) VALUES ('remove', ?, 'pending')",
-                        (json.dumps({"player_hash": player_hash}),),
-                    )
-                conn.commit()
-                return {"ok": True}
-            finally:
-                conn.close()
-
-    _maybe_start_drain()
-    log.info("achievements engine ready (%d feats, baseline v%s)",
-             len(_state["feat_defs"]), str(_state["baseline"].get("version", "?")))
-
-
-def _feat_payload(fid, feat, tier):
-    titles = feat.get("tier_titles") or []
-    title = titles[tier] if 0 <= tier < len(titles) else feat.get("title", fid)
-    return {
-        "id": fid,
-        "cls": "feat",
-        "tier": tier,
-        "title": title,
-        "description": feat.get("description", ""),
-        "category": feat.get("category", "global"),
-        "secret": bool(feat.get("secret", False)),
-    }
-
-
-def _earned_map(conn):
-    out = {}
-    for row in conn.execute(
-        "SELECT achievement_id, cls, disp_category, tier, unlocked_at FROM unlocks"
-    ):
-        out[row["achievement_id"]] = {
-            "id": row["achievement_id"],
-            "cls": row["cls"],
-            "category": row["disp_category"],
-            "tier": int(row["tier"]),
-            "unlocked_at": row["unlocked_at"],
-        }
-    return out

plugins/achievements/screen.js

@@ -1,395 +0,0 @@
-/*
- * Achievements & Feats of Power — frontend engine (vanilla, constitution P-II).
- *
- * Renders into the two core Profile mount points (achievements epic):
- *   #v3-profile-feats-slot        → earned Feats trophy shelf (hidden-until-earned)
- *   #v3-profile-achievements-mount → full competency catalogue (locked = greyed),
- *                                    grouped by instrument via a secondary pill row.
- * Re-injects on every `v3:profile-rendered` (core wipes the mounts each render).
- *
- * Also exposes the cross-plugin registration API `window.feedBack.achievements`
- * (v1) so source plugins (Virtuoso, notedetect, …) contribute competency defs +
- * report unlocks without us hardcoding their vocabulary. Load-order safe via the
- * `window.__feedBackAchievementsPending` queue + `achievements:ready` event.
- *
- * INTEGRATION LAW: Feats read activity counters only (we POST batched activity on
- * song:ended); competency Achievements are evaluated from progression EVENTS only.
- * The two paths never cross.
- */
-(function () {
-    'use strict';
-
-    var API = '/api/plugins/achievements';
-    var bus = window.feedBack;
-    if (!bus) return;  // bus must exist (capabilities.js); nothing to attach to.
-
-    var esc = function (s) {
-        return String(s == null ? '' : s).replace(/[&<>"']/g, function (c) {
-            return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c];
-        });
-    };
-
-    // ── State ────────────────────────────────────────────────────────────────
-    var registered = {};   // id -> def (contributed + expanded baseline defs)
-    var earned = {};       // id -> { tier, cls, category }
-    var baseline = null;   // /catalog baseline blob
-    var CAT_KEY = 'achievements:profile-cat';  // P-III: plugin localStorage keys prefixed with plugin id
-    var INSTRUMENTS = ['guitar', 'bass', 'drums', 'keys'];
-
-    function progState() {
-        return (window.v3Progression && window.v3Progression.get()) || null;
-    }
-    function notedetectPresent() {
-        return typeof window.createNoteDetector === 'function';
-    }
-
-    // ── Backend I/O ──────────────────────────────────────────────────────────
-    function fetchJSON(path, opts) {
-        return fetch(API + path, opts).then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
-    }
-    function postUnlock(def, tier) {
-        return fetch(API + '/report-unlock', {
-            method: 'POST', headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                id: def.id, kind: def.kind || 'achievement',
-                category: def.category || 'global', sourceId: def.sourceId || 'achievements',
-                tier: tier || 0,
-            }),
-        }).then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
-    }
-    function refreshEarned() {
-        return fetchJSON('/earned').then(function (data) {
-            earned = {};
-            ((data && data.earned) || []).forEach(function (e) { earned[e.id] = e; });
-        });
-    }
-
-    // ── Tier math (mirrors engine.tier_index_for) ────────────────────────────
-    function tierIndexFor(tiers, value) {
-        var idx = -1;
-        (tiers || []).forEach(function (t, i) { if (value >= t) idx = i; });
-        return idx;
-    }
-    function alreadyEarnedAtLeast(id, tier) {
-        var e = earned[id];
-        return e && e.tier >= tier;
-    }
-
-    // ── Registration API (v1) ────────────────────────────────────────────────
-    function register(def) {
-        if (!def || !def.id) return;
-        registered[def.id] = {
-            id: def.id, kind: def.kind || 'achievement', category: def.category || 'global',
-            title: def.title || def.id, description: def.description || '',
-            secret: !!def.secret, sourceId: def.sourceId || 'unknown',
-        };
-        scheduleRender();
-    }
-    function registerAll(defs) { (defs || []).forEach(register); }
-    function unlock(id, opts) {
-        var def = registered[id] || { id: id, kind: 'achievement', category: 'global', sourceId: 'unknown' };
-        var tier = (opts && opts.tier) || 0;
-        if (alreadyEarnedAtLeast(id, tier)) return Promise.resolve();
-        return postUnlock(def, tier).then(function () {
-            return refreshEarned().then(function () {
-                // A contributed Feat unlock would enqueue a wall sync here when
-                // opted-in (PR2/PR3); competency never syncs (integration law).
-                scheduleRender();
-            });
-        });
-    }
-    function progress() { /* accepted, optional — display is greyed/earned, not bars */ }
-
-    var api = { version: 1, register: register, registerAll: registerAll, unlock: unlock, progress: progress };
-    bus.achievements = api;
-    // Drain sources that loaded before us (minigames pending-queue pattern).
-    try { (window.__feedBackAchievementsPending || []).forEach(function (fn) {
-        try { typeof fn === 'function' ? fn(api) : register(fn); } catch (_) { /* noop */ }
-    }); } catch (_) { /* noop */ }
-    window.__feedBackAchievementsPending = null;
-    try { bus.emit && bus.emit('achievements:ready', { version: 1 }); } catch (_) { /* noop */ }
-
-    // ── Baseline competency: evaluate from progression EVENTS only ────────────
-    function expandBaseline() {
-        // Register baseline defs (always present — built-in progression is always
-        // present) so they render greyed even before they're earned. Per-instrument
-        // templates expand across the REAL paths that exist (auto-extends).
-        if (!baseline) return;
-        (baseline.global || []).forEach(function (d) {
-            register({ id: d.id, kind: 'achievement', category: 'global', title: d.title,
-                description: d.description, sourceId: 'achievements' });
-        });
-        var paths = (progState() && progState().paths) || [];
-        var pathIds = paths.length ? paths.map(function (p) { return { id: p.id, name: p.name }; })
-            : INSTRUMENTS.map(function (i) { return { id: i, name: i.charAt(0).toUpperCase() + i.slice(1) }; });
-        (baseline.per_instrument || []).forEach(function (tpl) {
-            pathIds.forEach(function (pi) {
-                var inst = pi.name;
-                register({
-                    id: tpl.id + ':' + pi.id, kind: 'achievement', category: pi.id,
-                    title: (tpl.title || '').replace(/\{Inst\}/g, inst),
-                    description: (tpl.description || '').replace(/\{Inst\}/g, inst),
-                    sourceId: 'achievements',
-                });
-            });
-        });
-    }
-
-    function evaluateBaseline() {
-        var prog = progState();
-        if (!prog || !baseline) return;
-        var defById = {};
-        (baseline.global || []).forEach(function (d) { defById[d.id] = d; });
-
-        // mastery_rank → first_steps / ascendant
-        (baseline.global || []).forEach(function (d) {
-            var crit = d.criterion || {};
-            if (crit.type === 'mastery_rank') {
-                var ti = tierIndexFor(crit.tiers || d.tiers, prog.mastery_rank || 0);
-                if (ti >= 0) baselineUnlock(d.id, 'global', ti);
-            } else if (crit.type === 'paths_at_level') {
-                var n = ((prog.paths) || []).filter(function (p) { return (p.level || 0) >= (crit.level || 10); }).length;
-                var ti2 = tierIndexFor(crit.tiers || d.tiers, n);
-                if (ti2 >= 0) baselineUnlock(d.id, 'global', ti2);
-            }
-        });
-
-        // per-instrument path_rank → reach Lv 10/25/max in that path
-        var tpl = (baseline.per_instrument || []).filter(function (t) { return t.id === 'path_rank'; })[0];
-        if (tpl) {
-            ((prog.paths) || []).forEach(function (p) {
-                var thresholds = (tpl.criterion && tpl.criterion.tiers) || [10, 25, 'max'];
-                var resolved = thresholds.map(function (t) { return t === 'max' ? (p.max_level || 9999) : t; });
-                var ti = tierIndexFor(resolved, p.level || 0);
-                if (ti >= 0) baselineUnlock('path_rank:' + p.id, p.id, ti);
-            });
-        }
-    }
-
-    function baselineUnlock(id, category, tier) {
-        if (alreadyEarnedAtLeast(id, tier)) return;
-        var def = registered[id] || { id: id, kind: 'achievement', category: category, sourceId: 'achievements' };
-        postUnlock(def, tier).then(function () { refreshEarned().then(scheduleRender); });
-    }
-
-    // Local calendar date 'YYYY-MM-DD' (one source of truth for both the
-    // steady-hands day ledger and the witching-night date below).
-    function localISODate(d) {
-        d = d || new Date();
-        return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
-    }
-
-    // growth-streak + challenger record on real competency events (date ledger /
-    // distinct challenge sets) — kept as bookkeeping over EVENTS, never activity.
-    function recordGrowthDay() {
-        var iso = localISODate();
-        fetchJSON('/report-criterion', {
-            method: 'POST', headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ criterion_id: 'steady_hands_days', token: iso }),
-        }).then(function (res) {
-            if (!res) return;
-            var d = ((baseline && baseline.global) || []).filter(function (x) { return x.id === 'steady_hands'; })[0];
-            var ti = tierIndexFor((d && d.tiers) || [7, 30, 100], res.count || 0);
-            if (ti >= 0) baselineUnlock('steady_hands', 'global', ti);
-        });
-    }
-
-    // ── Activity (Feats): in-memory session counters, flushed on song:ended ───
-    var session = { notesTotal: 0 };           // cumulative across this sitting
-    // `active` gates note counting to an actual song in progress — without it,
-    // note:hit/miss from the tuner or input-calibration would inflate Feats from
-    // non-song input and flush a phantom streak with chart:null.
-    var song = { hits: 0, streak: 0, maxStreak: 0, chart: null, active: false };
-    function resetSong(chart) { song = { hits: 0, streak: 0, maxStreak: 0, chart: chart || null, active: true }; }
-
-    function flushActivity(seconds) {
-        if (!song.active) return;   // no active song → nothing to flush (ignore stray events)
-        song.active = false;
-        // No notedetect → song.hits stays 0; notes-based Feats simply don't move
-        // (graceful degradation). song_done / seconds / chart still flow so the
-        // notedetect-free Feats (Road Warrior, Time Served, Encore) progress.
-        var hour = new Date().getHours();
-        var isNight = hour >= 2 && hour < 5;
-        var iso = localISODate();
-        var body = {
-            notes: song.hits,
-            session_notes: session.notesTotal,
-            in_song_streak: song.maxStreak,
-            song_done: 1,
-            seconds: Math.max(0, Math.round(seconds || 0)),
-            chart: song.chart,
-            night_session: isNight,
-            night_date: isNight ? iso : null,
-        };
-        fetchJSON('/activity', {
-            method: 'POST', headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-        }).then(function (res) {
-            if (res && res.unlocked && res.unlocked.length) {
-                // A Feat just unlocked — refresh the shelf + toast via the bus.
-                fetchFeatsAndRender();
-                res.unlocked.forEach(function (f) {
-                    try { bus.emit && bus.emit('achievements:feat-unlocked', f); } catch (_) { /* noop */ }
-                });
-            }
-        });
-    }
-
-    // ── Rendering ────────────────────────────────────────────────────────────
-    var _renderQueued = false;
-    function scheduleRender() {
-        if (_renderQueued) return;
-        _renderQueued = true;
-        (window.requestAnimationFrame || window.setTimeout)(function () { _renderQueued = false; renderAll(); }, 0);
-    }
-
-    function renderAll() {
-        renderCatalog();
-        fetchFeatsAndRender();
-    }
-
-    function categoriesForDisplay() {
-        var cats = [{ id: 'global', name: 'Global' }];
-        var paths = (progState() && progState().paths) || [];
-        if (paths.length) {
-            paths.forEach(function (p) { cats.push({ id: p.id, name: p.name }); });
-        } else {
-            // Fallback before progression loads: show the known instrument cats
-            // that actually have registered items.
-            INSTRUMENTS.forEach(function (i) {
-                if (Object.keys(registered).some(function (id) { return registered[id].category === i; })) {
-                    cats.push({ id: i, name: i.charAt(0).toUpperCase() + i.slice(1) });
-                }
-            });
-        }
-        return cats;
-    }
-
-    function itemsForCategory(catId) {
-        return Object.keys(registered).map(function (id) { return registered[id]; })
-            .filter(function (d) { return (d.category || 'global') === catId; })
-            // Hide un-earned secret items (revealed only once earned).
-            .filter(function (d) { return !d.secret || earned[d.id]; });
-    }
-
-    function renderCatalog() {
-        var mount = document.getElementById('v3-profile-achievements-mount');
-        if (!mount) return;
-        // Hide the core empty-state note now that we own this mount.
-        var emptyNote = document.querySelector('[data-empty-for="v3-profile-achievements-mount"]');
-        if (emptyNote) emptyNote.style.display = 'none';
-
-        var cats = categoriesForDisplay();
-        var saved = null;
-        try { saved = localStorage.getItem(CAT_KEY); } catch (_) { /* noop */ }
-        // Default to the player's primary path (first path), fallback Global.
-        var primary = (progState() && progState().paths && progState().paths[0] && progState().paths[0].id) || 'global';
-        var active = cats.some(function (c) { return c.id === saved; }) ? saved
-            : (cats.some(function (c) { return c.id === primary; }) ? primary : 'global');
-
-        var pills = cats.map(function (c) {
-            var items = itemsForCategory(c.id);
-            var got = items.filter(function (d) { return earned[d.id]; }).length;
-            return '<button type="button" class="fb-ach-pill' + (c.id === active ? ' active' : '') +
-                '" data-cat="' + esc(c.id) + '">' + esc(c.name) +
-                ' <span class="fb-ach-pill-badge">' + got + '/' + items.length + '</span></button>';
-        }).join('');
-
-        var items = itemsForCategory(active);
-        var list = items.length ? items.map(function (d) {
-            var got = !!earned[d.id];
-            var tier = got ? (earned[d.id].tier || 0) : -1;
-            return '<div class="fb-ach-item' + (got ? ' earned' : ' locked') + '">' +
-                '<div class="fb-ach-item-icon">' + (got ? '🏅' : '🔒') + '</div>' +
-                '<div class="fb-ach-item-body">' +
-                '<div class="fb-ach-item-title">' + esc(d.title) +
-                (got && tier > 0 ? ' <span class="fb-ach-tier">tier ' + (tier + 1) + '</span>' : '') + '</div>' +
-                '<div class="fb-ach-item-desc">' + esc(d.description) + '</div>' +
-                '</div></div>';
-        }).join('') : '<p class="fb-tabpanel-empty">No achievements in this category yet.</p>';
-
-        mount.innerHTML =
-            '<div class="fb-ach-pillrow">' + pills + '</div>' +
-            '<div class="fb-ach-list">' + list + '</div>';
-        mount.querySelectorAll('[data-cat]').forEach(function (b) {
-            b.addEventListener('click', function () {
-                try { localStorage.setItem(CAT_KEY, b.dataset.cat); } catch (_) { /* noop */ }
-                renderCatalog();
-            });
-        });
-    }
-
-    function fetchFeatsAndRender() {
-        return fetchJSON('/feats').then(function (data) { renderFeats((data && data.feats) || []); });
-    }
-
-    function renderFeats(feats) {
-        var slot = document.getElementById('v3-profile-feats-slot');
-        if (!slot) return;
-        if (!feats.length) { slot.innerHTML = ''; return; }  // hidden-until-earned
-        var cards = feats.map(function (f) {
-            return '<div class="fb-feat-card" title="' + esc(f.description) + '">' +
-                '<div class="fb-feat-icon">🏆</div>' +
-                '<div class="fb-feat-title">' + esc(f.title) + '</div>' +
-                '<div class="fb-feat-desc">' + esc(f.description) + '</div>' +
-                '</div>';
-        }).join('');
-        // Opt-out users get a subtle wall hint linking to Settings (PR2 wires it).
-        var hint = '';
-        slot.innerHTML =
-            '<div class="bg-fb-card/80 backdrop-blur rounded-xl p-6 border border-fb-border/50">' +
-            '<h3 class="text-lg font-bold text-fb-text mb-3">Feats of Power</h3>' +
-            '<div class="fb-feat-shelf">' + cards + '</div>' + hint +
-            '</div>';
-    }
-
-    // ── Boot ─────────────────────────────────────────────────────────────────
-    function init() {
-        fetchJSON('/catalog').then(function (data) {
-            baseline = (data && data.baseline) || {};
-            ((data && data.earned) && (earned = {}, Object.keys(data.earned).forEach(function (id) { earned[id] = data.earned[id]; })));
-            expandBaseline();
-            evaluateBaseline();
-            scheduleRender();
-        });
-        // Re-inject on every profile entry (core wipes the mounts each render).
-        document.addEventListener('v3:profile-rendered', function () { renderAll(); });
-
-        // Competency events → re-expand (paths may have appeared) + re-evaluate.
-        ['progression:updated', 'progression:rank-changed', 'progression:path-level-up'].forEach(function (ev) {
-            bus.on && bus.on(ev, function () { expandBaseline(); evaluateBaseline(); });
-        });
-        // A real competency advance ticks the growth-streak day ledger.
-        ['progression:rank-changed', 'progression:path-level-up', 'progression:challenge-completed'].forEach(function (ev) {
-            bus.on && bus.on(ev, function () { recordGrowthDay(); });
-        });
-        // challenger:<inst> — clearing a full level-up set for a path.
-        bus.on && bus.on('progression:path-level-up', function (e) {
-            var pid = e && e.detail && (e.detail.path_id || e.detail.id);
-            if (pid) baselineUnlock('challenger:' + pid, pid, 0);
-        });
-
-        // Activity (Feats) — in-memory counters, flushed once per song.
-        bus.on && bus.on('song:loading', function (e) {
-            resetSong(e && e.detail && e.detail.filename);
-        });
-        bus.on && bus.on('note:hit', function () {
-            if (!song.active) return;   // ignore tuner/calibration note events
-            song.hits++; song.streak++; session.notesTotal++;
-            if (song.streak > song.maxStreak) song.maxStreak = song.streak;
-        });
-        bus.on && bus.on('note:miss', function () { if (song.active) song.streak = 0; });
-        bus.on && bus.on('song:ended', function (e) {
-            flushActivity(e && e.detail && (e.detail.time || e.detail.audioT));
-        });
-        // Song stopped/abandoned without a natural end → mark inactive so stray
-        // note events after it don't accrue against a phantom (chart:null) song.
-        bus.on && bus.on('song:stop', function () { song.active = false; });
-    }
-
-    if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', init, { once: true });
-    } else {
-        init();
-    }
-})();

plugins/achievements/settings.html

@@ -1,68 +0,0 @@
-<!-- Achievements plugin — Privacy panel (mounts under the Settings "System" tab
-     via settings.category). Owns the wall opt-in toggle (bound to the core
-     `achievements_enabled` setting) + the self-serve "Remove me from the wall"
-     action. Default OFF — nothing publishes until the user opts in. -->
-<div class="text-sm text-gray-300 space-y-4" data-ach-privacy>
-  <div>
-    <p>Your <strong>Achievements</strong> and <strong>Feats of Power</strong> live on your
-       <em>Profile</em> page and are local &amp; private by default.</p>
-  </div>
-
-  <label class="flex items-start gap-3 cursor-pointer">
-    <input type="checkbox" id="setting-achievements-enabled"
-           class="mt-1 h-4 w-4 rounded border-gray-600 bg-gray-800 text-sky-500 focus:ring-sky-500">
-    <span>
-      <span class="font-medium text-gray-200">Share my Feats of Power on the public wall</span>
-      <span class="block text-gray-400">Publishes only your display name and the rare
-        <strong>Feats</strong> you earn (activity milestones) — never songs, skills, or scores.
-        You can turn this off and remove yourself at any time.</span>
-    </span>
-  </label>
-
-  <div>
-    <button type="button" id="ach-remove-me"
-            class="px-3 py-1.5 rounded-md text-sm border border-red-500/40 text-red-300 hover:bg-red-500/10 transition">
-      Remove me from the wall
-    </button>
-    <span id="ach-remove-status" class="ml-2 text-xs text-gray-400"></span>
-  </div>
-</div>
-
-<script>
-(function () {
-    var root = document.currentScript && document.currentScript.previousElementSibling;
-    // The panel re-injects on each Settings entry; bind once per element.
-    var toggle = document.getElementById('setting-achievements-enabled');
-    if (!toggle || toggle.dataset.wired === '1') return;
-    toggle.dataset.wired = '1';
-
-    // Hydrate from the authoritative server setting.
-    fetch('/api/settings').then(function (r) { return r.ok ? r.json() : {}; }).then(function (d) {
-        toggle.checked = d && d.achievements_enabled === true;
-    }).catch(function () { /* offline — leave unchecked */ });
-
-    toggle.addEventListener('change', function () {
-        var on = !!toggle.checked;
-        try { localStorage.setItem('achievementsEnabled', on ? '1' : '0'); } catch (_) {}
-        fetch('/api/settings', {
-            method: 'POST', headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ achievements_enabled: on }),
-        }).catch(function () { /* best-effort; revert on failure */ });
-    });
-
-    var removeBtn = document.getElementById('ach-remove-me');
-    var status = document.getElementById('ach-remove-status');
-    if (removeBtn) {
-        removeBtn.addEventListener('click', function () {
-            removeBtn.disabled = true;
-            if (status) status.textContent = 'Removing…';
-            fetch('/api/plugins/achievements/remove-me', { method: 'POST' })
-                .then(function (r) {
-                    if (status) status.textContent = r.ok ? 'Removed. Your Feats stay on your Profile.' : 'Could not reach the server — try again.';
-                })
-                .catch(function () { if (status) status.textContent = 'Offline — queued; it will sync when you reconnect.'; })
-                .finally(function () { removeBtn.disabled = false; });
-        });
-    }
-})();
-</script>

plugins/app_tour_library/script.js

@@ -10,7 +10,7 @@
         id: 'library-provider',
         selector: '#lib-provider',
         title: 'Choose a library',
-        content: 'Use this menu to switch between your local library and any connected remote libraries. FeedBack remembers the last library you picked.',
+        content: 'Use this menu to switch between your local library and any connected remote libraries. Slopsmith remembers the last library you picked.',
         shape: 'spotlight',
         position: 'bottom',
         waitFor: '#lib-provider'
@@ -57,20 +57,20 @@
 
     function _register() {
         try {
-            window.feedBackTour.register(PLUGIN_ID, { screens: SCREENS, buildSteps: _buildSteps });
+            window.slopsmithTour.register(PLUGIN_ID, { screens: SCREENS, buildSteps: _buildSteps });
         } catch (e) {
             console.warn('[app_tour_library] register failed', e);
         }
     }
 
-    if (window.feedBackTour && typeof window.feedBackTour.register === 'function') {
+    if (window.slopsmithTour && typeof window.slopsmithTour.register === 'function') {
         _register();
     } else {
         // Engine inits on DOMContentLoaded after fetching /api/plugins. Plugin
         // scripts can load before or after that handler runs, so poll briefly.
         var deadline = performance.now() + 5000;
         var pollId = setInterval(function () {
-            if (window.feedBackTour && typeof window.feedBackTour.register === 'function') {
+            if (window.slopsmithTour && typeof window.slopsmithTour.register === 'function') {
                 clearInterval(pollId);
                 _register();
             } else if (performance.now() > deadline) {
@@ -93,9 +93,9 @@
         var s = document.createElement('style');
         s.id = STYLE_ID;
         s.textContent =
-            'body.' + NUDGE_CLASS + ' .feedBack-tour-menu-btn { bottom: 68px; }' +
-            'body.' + NUDGE_CLASS + ' .feedBack-tour-menu-popover { bottom: 112px; }' +
-            'body.' + NUDGE_CLASS + ' .feedBack-tour-prompt { bottom: 112px; }';
+            'body.' + NUDGE_CLASS + ' .slopsmith-tour-menu-btn { bottom: 68px; }' +
+            'body.' + NUDGE_CLASS + ' .slopsmith-tour-menu-popover { bottom: 112px; }' +
+            'body.' + NUDGE_CLASS + ' .slopsmith-tour-prompt { bottom: 112px; }';
         document.head.appendChild(s);
     }
 
@@ -109,8 +109,8 @@
         // Prime from whichever screen is already active.
         var active = document.querySelector('.screen.active');
         _applyNudge(active ? active.id : null);
-        if (window.feedBack && typeof window.feedBack.on === 'function') {
-            window.feedBack.on('screen:changed', function (ev) {
+        if (window.slopsmith && typeof window.slopsmith.on === 'function') {
+            window.slopsmith.on('screen:changed', function (ev) {
                 _applyNudge(ev && ev.detail && ev.detail.id);
             });
         }

plugins/app_tour_library/tour.json

@@ -3,7 +3,7 @@
     "tour": [
         {
             "id": "welcome",
-            "title": "Welcome to FeedBack",
+            "title": "Welcome to Slopsmith",
             "content": "This is your library — every song we found in your library folder. Let's take a quick spin through the controls.",
             "shape": "bubble",
             "position": "auto"