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.

backend/tagwriter/pipeline.go

@@ -7,8 +7,6 @@ import (
 	"log/slog"
 	"time"
 
-	wailsruntime "github.com/wailsapp/wails/v2/pkg/runtime"
-
 	"yellowjacket/backend/database"
 	"yellowjacket/backend/events"
 )
@@ -175,8 +173,8 @@ func (tw *TagWriter) WriteTrackTags(trackID int64, changes TagChanges) error {
 	}
 
 	// 7. Emit event (suppressed during batch writes).
-	if tw.ctx != nil && !tw.suppressEvents {
-		wailsruntime.EventsEmit(tw.ctx, events.TrackMetadataChanged,
+	if !tw.suppressEvents {
+		events.Emit(tw.ctx, events.TrackMetadataChanged,
 			map[string]any{
 				"trackId":  trackID,
 				"filePath": audioFile.FilePath,
@@ -214,6 +212,22 @@ func (tw *TagWriter) WriteUntrackedFileTags(
 		return errNoChanges
 	}
 
+	return WriteFileTags(tw.logger, filePath, changes)
+}
+
+// WriteFileTags writes tags straight to an audio file, with no
+// database, player or lock involvement.  It is the format-dispatch
+// half of WriteUntrackedFileTags, exported so tooling that has no
+// app to construct — the fixture generator in cmd/gentestdata — can
+// tag files with the same writers the app uses, rather than growing a
+// second tagger that is free to drift from this one.
+//
+// Callers owning a *TagWriter should use WriteUntrackedFileTags.
+func WriteFileTags(
+	logger *slog.Logger,
+	filePath string,
+	changes TagChanges,
+) error {
 	format, err := DetectFormat(filePath)
 	if err != nil {
 		return fmt.Errorf("detect format: %w", err)
@@ -221,13 +235,13 @@ func (tw *TagWriter) WriteUntrackedFileTags(
 
 	switch format {
 	case FormatMP3:
-		err = writeMp3Tags(tw.logger, filePath, changes)
+		err = writeMp3Tags(logger, filePath, changes)
 	case FormatFLAC:
-		err = writeFlacTags(tw.logger, filePath, changes)
+		err = writeFlacTags(logger, filePath, changes)
 	case FormatWAV:
-		err = writeWavTags(tw.logger, filePath, changes)
+		err = writeWavTags(logger, filePath, changes)
 	case FormatOGG:
-		err = writeOggTags(tw.logger, filePath, changes)
+		err = writeOggTags(logger, filePath, changes)
 	default:
 		err = fmt.Errorf("%w: %s", errUnsupportedFormat, format)
 	}
@@ -334,30 +348,26 @@ func (tw *TagWriter) BatchWriteTrackTags(
 		}
 
 		// Emit progress after each track (success or failure).
-		if tw.ctx != nil {
-			wailsruntime.EventsEmit(tw.ctx,
-				events.BatchWriteProgress,
-				map[string]any{
-					"current":   i + 1,
-					"total":     total,
-					"filePath":  filePath,
-					"succeeded": result.Succeeded,
-					"failed":    result.Failed,
-				},
-			)
-		}
+		events.Emit(tw.ctx,
+			events.BatchWriteProgress,
+			map[string]any{
+				"current":   i + 1,
+				"total":     total,
+				"filePath":  filePath,
+				"succeeded": result.Succeeded,
+				"failed":    result.Failed,
+			},
+		)
 	}
 
 	// Emit a single TrackMetadataChanged after the batch completes
 	// so the library store invalidates once rather than per-track.
-	if tw.ctx != nil {
-		wailsruntime.EventsEmit(tw.ctx, events.TrackMetadataChanged,
-			map[string]any{
-				"batch": true,
-				"total": result.Succeeded,
-			},
-		)
-	}
+	events.Emit(tw.ctx, events.TrackMetadataChanged,
+		map[string]any{
+			"batch": true,
+			"total": result.Succeeded,
+		},
+	)
 
 	tw.logger.Info("batch write complete",
 		"total", total,