test: full test-suite refactor sweep (#61)

* chore(test): start test-suite refactor sweep

* test(ltl): pin exact multi-obligation residual AST

* test(ltl): table-test finalize Kleene connective combinations

* test(ltl): pin reduce over pending inner for bound, Or, Not

* test(ltl): marshal bounded Always steps/duration/deadline

* test(verifier): cover LTL combinator verdict transitions and within unit panic

* test(verifier): table-test DecodeAction kinds and lastAction field exposure

* test(verifier): assert WithPlatform(ios) reaches the picker host and key pool

* test(verifier): widen weighted-selection assertion to a 5x skew margin

* test(verifier): un-skip ax-find round trip with a committed tree fixture

* test(runner): pin isWDADrop to sidecar reconnect-failed message origin

* test(runner): assert PressKey/Wait trace encoding records kind-specific fields

* test(runner): cover RenderSummary unsupported-verbs surfacing branch

* test(trace): set Hierarchy in round-trip and lock lossy Tree contract

Also add a -race concurrent WriteStep test that asserts N well-formed JSONL lines, catching torn lines if the writer mutex is dropped.

* test(trace): round-trip witnesses/changes/metrics/exceptions, pin step-0 witness

* test(trace): document ViolationsAreGreppable grep contract and lock-free WriteScreenshot

* test(hierarchy): cover invalid-JSON and malformed-bounds parser paths

* test(trace): guard writer mutex via WriteStep/Close race on w.file

* test(replay): drop unfailable assets and devproxy assertions

* test(replay): cache reuses on equal mtime, reparses after append

* test(replay): violation marker falls back to detection step when attributed missing

* test(replay): corrupt meta/trace dirs return 500 with error body

* test(replay): SSE client receives runs.changed after a broadcast

* test(replay): Run coalesces creates, ignores write/chmod, closes subs on cancel

* fix(sidecar): synchronize health fixture writes and exercise healthError

* test(sidecar): cover swipe/longpress/doubletap/erase/presskey/metrics/logs translations

* test(sidecar): cover DoubleTapSelector composition and mid-gesture cancel

* test(sidecar): assert gRPC error status surfaces from action RPC

* fix(chrome): route action methods through runCtx so caller cancellation aborts CDP

* fix(chrome): route hierarchy/screenshot/waitidle/metrics through runCtx

* refactor(ios): extract pure simctl JSON parsers

* refactor(ios): add command-runner seams for EnsureSimulator

* test(ios): table-test simctl parsers and EnsureSimulator seams

* test(sidecarassets): cover placeholder build path

* test(sidecarassets): assert reuse via sentinel bytes not mtime

* test(bundler): cover properties-only spec registration

* refactor(testrun): extract prepareBundleInputs from Execute

* test(testrun): cover prepareBundleInputs aliases and missing-runtime error

* test(testrun): table-test resolveRuntimeSibling search edges

* test(testrun): exact-output tests for progressHandler line format

* fix(cmd): point bundle-check aliases at pkg/spec/src

* test(cmd): smoke-test bundle-check resolves spec aliases

* test(cmd): table-test hier-check parse and FindAll on fixture

* test(cmd): unit-test buildBrowseURL deep-link vs root

* test(cmd): drop flaky TestRun_Doctor that launched real Chromium

* test(cmd): pin pipeline error to bundle resolution on web platform

* test(replay-ui): add bun test script

* ci(replay-ui): run bun test via make web-test target

* ci(replay-ui): point bun cache key at replay-ui/bun.lock

* test(replay-ui): exercise real URL encoding and non-ok throw in getJson

* refactor(replay-ui): extract snapshot flatten/getAtPath into lib module

* test(replay-ui): pin snapshot flatten/getAtPath path round-trip

* refactor(replay-ui): extract action selector/format into lib module

* test(replay-ui): pin action selector parse and row formatting

* refactor(replay-ui): share one statusFor between panels

* refactor(replay-ui): extract run-history derivation into lib module

* test(replay-ui): pin shared statusFor precedence and ordering

* test(replay-ui): pin run-history derivation alignment

* refactor(replay-ui): export clampIndex for testing

* refactor(replay-ui): extract keyboard-nav dispatch into pure module

* refactor(replay-ui): extract metrics formatters into lib module

* test(replay-ui): pin clampIndex step boundaries

* test(replay-ui): pin keyboard-nav ownership and key routing

* test(replay-ui): pin metrics formatters and path gap handling

* refactor(sidecar): expose device-output parsers as internal for testing

* test(sidecar): table-test device-output parsers against malformed input

* test(sidecar): cover logcat parsing year inference and line skipping

* test(sidecar): pin pressKey keycode mapping and unknown-key rejection

* test(sidecar): metrics bundleId falls back to launched app and honors override

* test(sidecar): loosen deadline upper bound to tolerate slow CI scheduling

* test(web-runtime): export selector builders for unit tests

* test(web-runtime): guard sanitize cycle, function, and depth limits

* test(web-runtime): table-test selector builder quoting and escaping

* test(sidecar): collapse scalar-forwarding RPC tests into a table

* test(replay-ui): dedup step/summary fixtures into shared module

* test(ios): collapse pickSimulator point-tests into a table

internal/replay/runs_test.go

@@ -198,6 +198,79 @@ func TestCacheOpen_ViolationWithoutWitnessStepKeepsDetectionStep(t *testing.T) {
 	}
 }
 
+func TestCacheOpen_ReusesUnchangedRunAndReparsesOnAppend(t *testing.T) {
+	root := t.TempDir()
+	startedAt := time.Now().UTC()
+	writeRun(t, root, "r1", trace.Meta{StartedAt: startedAt}, []trace.Step{
+		{Index: 1, Timestamp: startedAt},
+	})
+	cache := NewCache(root)
+
+	first, err := cache.Open("r1")
+	if err != nil {
+		t.Fatalf("Open: %v", err)
+	}
+	again, err := cache.Open("r1")
+	if err != nil {
+		t.Fatalf("Open again: %v", err)
+	}
+	if first != again {
+		t.Fatal("unchanged run should be served from cache, got a re-parse")
+	}
+
+	tracePath := filepath.Join(root, "r1", "trace.jsonl")
+	file, err := os.OpenFile(tracePath, os.O_APPEND|os.O_WRONLY, 0o644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.NewEncoder(file).Encode(trace.Step{Index: 2, Timestamp: startedAt.Add(time.Second)}); err != nil {
+		t.Fatal(err)
+	}
+	file.Close()
+	bumped := first.traceMtime.Add(time.Second)
+	if err := os.Chtimes(tracePath, bumped, bumped); err != nil {
+		t.Fatal(err)
+	}
+
+	updated, err := cache.Open("r1")
+	if err != nil {
+		t.Fatalf("Open after append: %v", err)
+	}
+	if updated == first {
+		t.Fatal("mtime bump should force a re-parse, got the stale cached run")
+	}
+	if len(updated.Steps) != 2 {
+		t.Errorf("re-parsed steps = %d, want 2", len(updated.Steps))
+	}
+}
+
+func TestCacheOpen_ViolationFallsBackToDetectionStepWhenAttributedMissing(t *testing.T) {
+	// The witness attributes the violation to step 99, which never appears in
+	// the trace. The marker must fall back to the detection step (2) so the
+	// violation still renders somewhere instead of vanishing.
+	root := t.TempDir()
+	startedAt := time.Now().UTC()
+	steps := []trace.Step{
+		{Index: 1, Timestamp: startedAt},
+		{
+			Index:      2,
+			Timestamp:  startedAt.Add(time.Second),
+			Violations: []string{"prop1"},
+			Witnesses:  map[string]trace.Witness{"prop1": {Reason: "predicate false", Step: 99}},
+		},
+	}
+	writeRun(t, root, "r1", trace.Meta{StartedAt: startedAt, EndedAt: timePointer(startedAt.Add(2 * time.Second))}, steps)
+
+	cache := NewCache(root)
+	run, err := cache.Open("r1")
+	if err != nil {
+		t.Fatalf("Open: %v", err)
+	}
+	if !run.Steps[1].HasViolations {
+		t.Error("step 2 (detection step) should keep the marker when the attributed step is absent")
+	}
+}
+
 func TestDecodeStepSummary_ActionLabelPerKind(t *testing.T) {
 	cases := []struct {
 		line      string

internal/replay/server_test.go

@@ -7,7 +7,6 @@ import (
 	"io/fs"
 	"net/http"
 	"net/http/httptest"
-	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
@@ -158,6 +157,47 @@ func TestHandleStep_ErrorCases(t *testing.T) {
 	}
 }
 
+func TestServer_CorruptRunDirReturns500WithError(t *testing.T) {
+	root := t.TempDir()
+	mustWriteFile(t, filepath.Join(root, "bad-meta", "meta.json"), "{not json")
+	mustWriteFile(t, filepath.Join(root, "bad-trace", "meta.json"), `{"started_at":"2026-04-17T18:00:00Z"}`)
+	mustWriteFile(t, filepath.Join(root, "bad-trace", "trace.jsonl"), "{not json\n")
+
+	server, err := NewServer(ServerOptions{RunsDirectory: root, AssetsFS: testAssetsFS})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cases := []string{
+		"/api/runs/bad-meta",
+		"/api/runs/bad-trace",
+		"/api/runs/bad-trace/steps/1",
+	}
+	for _, path := range cases {
+		t.Run(path, func(t *testing.T) {
+			recorder := httptest.NewRecorder()
+			request := httptest.NewRequest(http.MethodGet, path, nil)
+			server.Handler().ServeHTTP(recorder, request)
+			if recorder.Code != http.StatusInternalServerError {
+				t.Fatalf("status = %d, want 500, body=%s", recorder.Code, recorder.Body.String())
+			}
+			if strings.TrimSpace(recorder.Body.String()) == "" {
+				t.Error("expected a non-empty error body")
+			}
+		})
+	}
+}
+
+func mustWriteFile(t *testing.T, path, body string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestScreenshot_ServesWhitelistedPNG(t *testing.T) {
 	server, _ := newFixtureServer(t)
 	recorder := httptest.NewRecorder()
@@ -223,6 +263,57 @@ func TestSSE_ReturnsWhenContextCanceled(t *testing.T) {
 	}
 }
 
+func TestSSE_DeliversRunsChangedAfterBroadcast(t *testing.T) {
+	server, _ := newFixtureServer(t)
+	httpServer := httptest.NewServer(server.Handler())
+	defer httpServer.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, httpServer.URL+"/api/events", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	response, err := http.DefaultClient.Do(request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer response.Body.Close()
+
+	events := make(chan string, 1)
+	go func() {
+		buffer := make([]byte, 256)
+		for {
+			n, err := response.Body.Read(buffer)
+			if n > 0 {
+				events <- string(buffer[:n])
+			}
+			if err != nil {
+				return
+			}
+		}
+	}()
+
+	deadline := time.Now().Add(2 * time.Second)
+	for {
+		server.Watcher().broadcast()
+		select {
+		case got := <-events:
+			if strings.Contains(got, ": ping") {
+				continue
+			}
+			if !strings.Contains(got, "event: runs.changed") {
+				t.Fatalf("event = %q, want runs.changed", got)
+			}
+			return
+		case <-time.After(50 * time.Millisecond):
+			if time.Now().After(deadline) {
+				t.Fatal("client never received runs.changed after broadcast")
+			}
+		}
+	}
+}
+
 func TestDevProxy_ForwardsRequestBodyUnchanged(t *testing.T) {
 	received := make(chan string, 1)
 	upstream := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
@@ -275,8 +366,8 @@ func TestAssets_FallbackToIndexHTML(t *testing.T) {
 		t.Fatalf("status = %d", recorder.Code)
 	}
 	body := recorder.Body.String()
-	if !strings.Contains(body, "<div id=\"app\"></div>") && !strings.Contains(body, "<div id=\"root\"></div>") {
-		t.Errorf("expected SPA shell with #app or #root, got %q", body)
+	if !strings.Contains(body, "<div id=\"root\"></div>") {
+		t.Errorf("expected SPA shell with #root, got %q", body)
 	}
 }
 
@@ -312,12 +403,8 @@ func TestResolveRunsDirectory(t *testing.T) {
 	}
 }
 
-func TestDevProxy_ParsesTarget(t *testing.T) {
+func TestDevProxy_RejectsInvalidTarget(t *testing.T) {
 	if _, err := newDevProxy(":://bad-url"); err == nil {
 		t.Error("expected parse error for invalid URL")
 	}
-	parsed, err := url.Parse(DevTarget)
-	if err != nil || parsed.Host != "127.0.0.1:5173" {
-		t.Errorf("DevTarget parsed wrong: %v %q", err, parsed.Host)
-	}
 }

internal/replay/watcher_test.go

@@ -1,9 +1,128 @@
 package replay
 
 import (
+	"context"
+	"os"
+	"path/filepath"
 	"testing"
+	"time"
 )
 
+func TestWatcher_RunCoalescesCreateBurstIntoOneBroadcast(t *testing.T) {
+	directory := t.TempDir()
+	w := NewWatcher(directory)
+	w.debounce = 30 * time.Millisecond
+	events := w.Subscribe()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() { _ = w.Run(ctx) }()
+	defer cancel()
+	waitForWatch(t, w.debounce)
+
+	for i := 0; i < 5; i++ {
+		mustCreate(t, filepath.Join(directory, "run-"+string(rune('a'+i)), "meta.json"))
+	}
+
+	select {
+	case <-events:
+	case <-time.After(time.Second):
+		t.Fatal("burst of creates produced no broadcast")
+	}
+	if extra := drainWithin(events, 4*w.debounce); extra != 0 {
+		t.Errorf("burst yielded %d extra broadcasts, want a single coalesced one", extra)
+	}
+}
+
+func TestWatcher_RunIgnoresWriteAndChmod(t *testing.T) {
+	directory := t.TempDir()
+	existing := filepath.Join(directory, "marker")
+	if err := os.WriteFile(existing, []byte("{}"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	w := NewWatcher(directory)
+	w.debounce = 30 * time.Millisecond
+	events := w.Subscribe()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() { _ = w.Run(ctx) }()
+	defer cancel()
+	waitForWatch(t, w.debounce)
+
+	if err := os.WriteFile(existing, []byte("touched"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chmod(existing, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if got := drainWithin(events, 6*w.debounce); got != 0 {
+		t.Errorf("write/chmod produced %d broadcasts, want 0", got)
+	}
+}
+
+func TestWatcher_RunCancelClosesSubscribers(t *testing.T) {
+	w := NewWatcher(t.TempDir())
+	w.debounce = 30 * time.Millisecond
+	events := w.Subscribe()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() { _ = w.Run(ctx) }()
+	waitForWatch(t, w.debounce)
+	cancel()
+
+	select {
+	case _, ok := <-events:
+		if ok {
+			// drain any pending broadcast, then expect close
+			_, ok = <-events
+		}
+		if ok {
+			t.Fatal("subscriber channel should be closed after ctx cancel")
+		}
+	case <-time.After(time.Second):
+		t.Fatal("subscriber channel was not closed after ctx cancel")
+	}
+
+	post := w.Subscribe()
+	select {
+	case _, ok := <-post:
+		if ok {
+			t.Error("Subscribe after shutdown should return a pre-closed channel")
+		}
+	case <-time.After(time.Second):
+		t.Error("Subscribe after shutdown blocked instead of returning a closed channel")
+	}
+}
+
+func mustCreate(t *testing.T, path string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte("{}"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func waitForWatch(t *testing.T, debounce time.Duration) {
+	t.Helper()
+	time.Sleep(10 * debounce)
+}
+
+func drainWithin(events <-chan struct{}, window time.Duration) int {
+	count := 0
+	deadline := time.After(window)
+	for {
+		select {
+		case <-events:
+			count++
+		case <-deadline:
+			return count
+		}
+	}
+}
+
 func TestWatcher_UnsubscribeRemovesChannel(t *testing.T) {
 	w := NewWatcher(t.TempDir())
 	first := w.Subscribe()