feat(harness): agent-drivable dev harness and CI that gates

A coding agent could develop this repo's Go packages and could not
develop the application: every path to running YellowJacket ended in a
blocking GTK window, so 265 bound methods, 46 events, 33 component
directories and 13 stores had exactly one form of verification
available — `tsc --noEmit`.

The unlock is that `wails dev`'s dev server on :34115 serves the real
frontend with the real generated bindings against the same Go backend a
desktop window attaches to, so a plain Chromium under Xvfb gets a fully
functional app. Four test tiers now exist, cheapest first:

- `make ui-test` — 313 Vitest tests in a real browser in ~2 s, no app,
  no backend, no display. Works because `frontend/wailsjs/` is a pure
  passthrough to `window.go`/`window.runtime`, so faking just those two
  globals runs the real bindings and the real store code.
- `make test` — services in-process, asserting on the payload the
  frontend would receive, via a new `events.Emit` wrapper.
- `make dev-headless` + `playwright-cli` — the real app, driven
  interactively, with an event bridge on `window.__yjEvents` and a
  dev-only control surface at `/__test/`.
- `make e2e` — 19 of those flows frozen as Playwright specs.

`events.Emit(ctx, …)` replaces all 35 direct `runtime.EventsEmit` call
sites: wails' `getEvents` `log.Fatalf`s on any context without its
runtime, so those paths could not run under test and a background
worker could take the app down. Four packages had each hand-rolled the
same guard; nine more guarded on `ctx != nil`, which does not help.
`TestNoDirectRuntimeEmits` fails the build on a new one.

Fixtures are generated, not committed (`make testdata`), and seeds are
built by *running the app* — never by hand-writing config and DB rows,
which would be a second description of a valid YJ_HOME.

`.gitea/workflows/ci.yml` is the first workflow here that tests
anything; the other three only package, so `gitea_ci` reported only
packaging jobs and misled anyone asking whether a push was healthy.
Both jobs were prototyped to green in a bare ubuntu:24.04 container
before the YAML was written, which immediately caught `make lint`
linting three configurations that nothing builds: all three passes
omitted `webkit2_41`, so wails resolved webkit2gtk-4.0 — which Arch
still ships and Ubuntu 24.04 dropped.

Operational instructions live in `.pi/skills/yellowjacket-dev/`,
measured discoveries in `.planning/NOTES.md`, and architecture in
`CLAUDE.md` — split by tense, not by topic, because a topical split
gives every new fact two plausible homes. `make skill-check` fails a
commit if the skill cites a make target that does not exist.

internal/testfixtures/testfixtures.go

@@ -0,0 +1,190 @@
+// Package testfixtures gives tests typed access to the deterministic
+// fixture library produced by cmd/gentestdata (`make testdata`).
+//
+// The library is gitignored and generated, so every accessor here
+// skips the calling test when it is absent rather than failing: a
+// clean clone must still be able to run `go test ./...`.  Tests select
+// fixtures by case name — the behaviour they exercise — so fixture
+// paths can be renamed without touching test code.
+package testfixtures
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+)
+
+// ManifestName is the manifest's filename, kept outside the library
+// root so the scanner never sees it.
+const ManifestName = "music_library_test.manifest.json"
+
+// Case names, mirroring cmd/gentestdata's spec.
+const (
+	CaseCoverDedup    = "cover-dedup"
+	CaseMultiDisc     = "multi-disc"
+	CaseVariousArtist = "various-artists"
+	CaseFLACAlbum     = "flac-album"
+	CaseOGGAlbum      = "ogg-album"
+	CaseWAVTracks     = "wav-tracks"
+	CasePartialTags   = "partial-tags"
+	CaseUnicode       = "unicode"
+	CaseDuplicates    = "duplicates"
+	CaseEdgeLengths   = "edge-lengths"
+	CaseBroken        = "broken"
+)
+
+// Track is one generated fixture, as specified rather than as encoded.
+type Track struct {
+	Path       string         `json:"path"`
+	Case       string         `json:"case"`
+	Format     string         `json:"format"`
+	DurationMS int64          `json:"durationMs"`
+	FreqHz     float64        `json:"freqHz"`
+	Cover      string         `json:"cover,omitempty"`
+	CoverSHA   string         `json:"coverSha,omitempty"`
+	Tags       map[string]any `json:"tags"`
+}
+
+// Manifest describes a generated fixture library.
+type Manifest struct {
+	Version     int                 `json:"version"`
+	Generator   string              `json:"generator"`
+	Hash        string              `json:"hash"`
+	LibraryRoot string              `json:"libraryRoot"`
+	BrokenRoot  string              `json:"brokenRoot"`
+	Cases       map[string][]string `json:"cases"`
+	Tracks      []Track             `json:"tracks"`
+	Extras      []string            `json:"extras"`
+	Broken      []string            `json:"broken"`
+
+	repoRoot string
+}
+
+// Root returns the absolute path of the fixture library root.
+func (m *Manifest) Root() string {
+	return filepath.Join(m.repoRoot, filepath.FromSlash(m.LibraryRoot))
+}
+
+// BrokenPath returns the absolute path of the malformed-file root,
+// which is deliberately a sibling of the library rather than part of
+// it: the clean library's track count has to stay deterministic.
+func (m *Manifest) BrokenPath() string {
+	return filepath.Join(m.repoRoot, filepath.FromSlash(m.BrokenRoot))
+}
+
+// Abs resolves a manifest-relative track path to an absolute one.
+func (m *Manifest) Abs(rel string) string {
+	return filepath.Join(m.Root(), filepath.FromSlash(rel))
+}
+
+// Case returns the absolute paths belonging to a case, failing the
+// test when the case is unknown — a typo should not silently pass as
+// an empty set.
+func (m *Manifest) Case(t *testing.T, name string) []string {
+	t.Helper()
+
+	rels, ok := m.Cases[name]
+	if !ok {
+		t.Fatalf("testfixtures: unknown case %q", name)
+	}
+
+	paths := make([]string, 0, len(rels))
+	for _, rel := range rels {
+		paths = append(paths, m.Abs(rel))
+	}
+
+	return paths
+}
+
+// Track looks up a fixture by its manifest-relative path.
+func (m *Manifest) Track(t *testing.T, rel string) Track {
+	t.Helper()
+
+	for _, track := range m.Tracks {
+		if track.Path == rel {
+			return track
+		}
+	}
+
+	t.Fatalf("testfixtures: no fixture at %q", rel)
+
+	return Track{}
+}
+
+//nolint:gochecknoglobals // memoised manifest load, keyed to the process.
+var (
+	loadOnce sync.Once
+	loaded   *Manifest
+)
+
+// Load returns the fixture manifest, skipping the test when the
+// library has not been generated (`make testdata`).
+func Load(t *testing.T) *Manifest {
+	t.Helper()
+
+	loadOnce.Do(func() {
+		loaded = load()
+	})
+
+	if loaded == nil {
+		t.Skip(
+			"testfixtures: fixture library not generated; " +
+				"run `make testdata`",
+		)
+	}
+
+	return loaded
+}
+
+// load reads and validates the manifest, returning nil when the
+// fixtures are missing or stale.
+func load() *Manifest {
+	repo, err := repoRoot()
+	if err != nil {
+		return nil
+	}
+
+	raw, err := os.ReadFile(filepath.Join(repo, "test_data", ManifestName))
+	if err != nil {
+		return nil
+	}
+
+	var m Manifest
+	if err := json.Unmarshal(raw, &m); err != nil {
+		return nil
+	}
+
+	m.repoRoot = repo
+
+	// A manifest without its library is worse than no manifest: it
+	// would point every test at paths that do not exist.
+	if _, err := os.Stat(m.Root()); err != nil {
+		return nil
+	}
+
+	return &m
+}
+
+// repoRoot walks up from the working directory to the module root, so
+// fixtures resolve identically from any package's test.
+func repoRoot() (string, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir, nil
+		}
+
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return "", os.ErrNotExist
+		}
+
+		dir = parent
+	}
+}