feat: LTL operators, sampling, and default generators (#17)

* feat(ltl): add Now/Next/Eventually/Implies/Or/And/Not formulas

Replace the fold-with-latch evaluator with a residual-formula reducer.
Each Observe() instantiates a fresh obligation from the root (stripping
an outer Always), reduces each pending obligation against current state,
latches Violated on first failure, and surfaces Pending verdicts for
deferred obligations. Existing Always/Pure/Thunk tests continue to pass.

* feat(ltl): support relative duration for eventually().within()

* feat(proto): add Swipe, PressKey, RecentLogs RPCs

* feat(verifier,runner): formula handles, new action kinds, rich state

- verifier: add formula-spec registry; bindNow/bindNext/bindEventually with
  chainable .implies/.or/.and/.not and .within(n,unit) on eventually; bindFrom
  for uniform sampling. bindAlways keeps accepting plain predicates.
- verifier: store lastTree, lastAction, step time, logs, exceptions on the
  Verifier; SnapshotInput replaces the (snapshots, tree) pair. stateObject now
  produces state.lastAction/time/logs/exceptions matching the TS State type.
- verifier: make taps/swipes/waitOnce/pressKey built-in generators actually
  fire; taps picks a clickable, enabled element from the last hierarchy.
- agent: add exceptions field to Message wire format.
- driver: add Swipe/PressKey/RecentLogs to Driver interface; wire maestro
  client and mock driver. LogEntry exposed for runner consumption.
- runner: apply Swipe/PressKey/Wait actions; collect logcat and exceptions;
  pass lastAction and step time into PushSnapshot.

* feat(spec-api): LTL operators, new actions, richer State

- ltl.ts exports now/next/eventually; always overload accepts a Formula
- types.ts: Formula gains implies/or/and/not; EventuallyFormula adds .within;
  State gains lastAction/time/logs/exceptions; Swipe/PressKey/Wait action types
- actions.ts: Swipe/PressKey/Wait/from constructors; waitOnce + pressKey
  default generators
- tests exercise the chaining, sampling, and new actions through a recorded
  fake runtime

* feat(sidecar): add swipe, pressKey, recentLogs RPC handlers

* feat(sdk-android): capture uncaught exceptions

Install a default uncaught handler on Uatu.start, chained with any
existing handler so Android's crash reporter still runs. Expose
Uatu.reportError for callers to forward caught throwables. A bounded
circular buffer (default 50) drains into each STATE message's new
exceptions field. Protocol.kt serializes/deserializes the field,
matching the Go wire format added to internal/agent/protocol.go.

* feat(spec-api): add @uatu/spec/defaults/properties bundle

* feat(sample-app): exercise new LTL operators + defaults

spec.ts now imports eventually/next/now/from from @uatu/spec and
noUncaughtExceptions from @uatu/spec/defaults/properties. It declares
three properties that exercise the new surface:

- accountCountNonNegative: plain always() safety
- addAccountAdvances: always(now(x).implies(next(y)))
- eventuallyLoggedIn: eventually(p).within(30, "seconds")
- noUncaughtExceptions: imported default

The weighted actions root uses from() for random phone/name sampling
and entries for taps/swipes/waitOnce/pressKey built-ins.

SampleApplication gains a debug hook gated on the system property
uatu.inject_error so the e2e run can synthesize an Uatu.reportError and
verify noUncaughtExceptions violates.

cmd/uatu/test_run.go adds a subpath alias so specs importing
"@uatu/spec/defaults/properties" resolve against the in-tree source
when running from the uatu checkout. The spec-integration tests swap
the old click-counter fixtures for the new login hierarchy.

* feat(trace): record swipe/key/wait details + exceptions

trace.Step gains an Exceptions array so the trace captures the
class/message/stackTrace for each SDK-reported throwable in a step.
trace.Action gains FromX/FromY/ToX/ToY/Key/DurationMillis so the full
payload of Swipe/PressKey/Wait actions is visible in trace.jsonl.

sample-app's debug error hook now gates on ApplicationInfo.DEBUGGABLE
instead of a system property (adb setprop fails on non-rooted
emulators).

internal/runner/runner.go

@@ -56,6 +56,8 @@ func Run(ctx context.Context, options Options) (Summary, error) {
 	summary := Summary{StartTime: time.Now()}
 	deadline := summary.StartTime.Add(options.Duration)
 	stepIndex := 0
+	var lastAction *verifier.Action
+	var lastLogTime time.Time
 	for time.Now().Before(deadline) {
 		if err := ctx.Err(); err != nil {
 			break
@@ -82,7 +84,20 @@ func Run(ctx context.Context, options Options) (Summary, error) {
 			return summary, fmt.Errorf("step %d snapshot: %w", stepIndex, err)
 		}
 
-		if err := options.Verifier.PushSnapshot(verifier.Snapshots(snapshot.Snapshots), tree); err != nil {
+		logs := collectLogs(ctx, options.Driver, lastLogTime)
+		lastLogTime = stepStart
+
+		exceptions := decodeExceptions(snapshot)
+
+		if err := options.Verifier.PushSnapshot(verifier.SnapshotInput{
+			Snapshots:  verifier.Snapshots(snapshot.Snapshots),
+			Tree:       tree,
+			LastAction: lastAction,
+			StepTime:   stepStart,
+			RunStart:   summary.StartTime,
+			Logs:       logs,
+			Exceptions: exceptions,
+		}); err != nil {
 			return summary, fmt.Errorf("step %d push: %w", stepIndex, err)
 		}
 		screen, screenErr := screenFromSnapshot(snapshot.Snapshots)
@@ -108,6 +123,7 @@ func Run(ctx context.Context, options Options) (Summary, error) {
 			Screen:     screen,
 			Snapshots:  snapshot.Snapshots,
 			Action:     traceAction,
+			Exceptions: traceExceptions(exceptions),
 			Violations: violations,
 		}
 		if err := options.TraceWriter.WriteStep(step); err != nil {
@@ -129,6 +145,10 @@ func Run(ctx context.Context, options Options) (Summary, error) {
 			if err := applyAction(ctx, options.Driver, nextAction, tree); err != nil {
 				return summary, fmt.Errorf("step %d apply: %w", stepIndex, err)
 			}
+			actionCopy := nextAction
+			lastAction = &actionCopy
+		} else {
+			lastAction = nil
 		}
 
 		idleCtx, idleCancel := context.WithTimeout(ctx, options.IdleTimeout)
@@ -222,11 +242,71 @@ func applyAction(ctx context.Context, drv driver.Driver, action verifier.Action,
 			}
 		}
 		return drv.InputText(ctx, action.Text)
+	case verifier.ActionKindSwipe:
+		duration := time.Duration(action.DurationMillis) * time.Millisecond
+		if duration <= 0 {
+			duration = 250 * time.Millisecond
+		}
+		return drv.Swipe(ctx, action.FromX, action.FromY, action.ToX, action.ToY, duration)
+	case verifier.ActionKindPressKey:
+		if action.Key == "" {
+			return nil
+		}
+		return drv.PressKey(ctx, action.Key)
+	case verifier.ActionKindWait:
+		duration := time.Duration(action.DurationMillis) * time.Millisecond
+		if duration <= 0 {
+			return nil
+		}
+		timer := time.NewTimer(duration)
+		defer timer.Stop()
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-timer.C:
+			return nil
+		}
 	default:
 		return fmt.Errorf("unknown action kind %q", action.Kind)
 	}
 }
 
+// collectLogs pulls recent error-level log entries from the driver since the
+// previous fetch. A failure is warned-on but not fatal: log capture is a
+// best-effort observability channel, not a correctness dependency.
+func collectLogs(ctx context.Context, drv driver.Driver, since time.Time) []verifier.LogEntry {
+	entries, err := drv.RecentLogs(ctx, since, "E")
+	if err != nil {
+		return nil
+	}
+	result := make([]verifier.LogEntry, 0, len(entries))
+	for _, entry := range entries {
+		result = append(result, verifier.LogEntry{
+			UnixMillis: entry.UnixMillis,
+			Level:      entry.Level,
+			Tag:        entry.Tag,
+			Message:    entry.Message,
+		})
+	}
+	return result
+}
+
+func decodeExceptions(snapshot agent.Message) []verifier.Exception {
+	if len(snapshot.Exceptions) == 0 {
+		return nil
+	}
+	result := make([]verifier.Exception, 0, len(snapshot.Exceptions))
+	for _, e := range snapshot.Exceptions {
+		result = append(result, verifier.Exception{
+			Class:      e.Class,
+			Message:    e.Message,
+			StackTrace: e.StackTrace,
+			UnixMillis: e.UnixMillis,
+		})
+	}
+	return result
+}
+
 func resolveCoordinates(action verifier.Action, tree *hierarchy.Tree) (int, int, bool) {
 	if action.X > 0 && action.Y > 0 {
 		return action.X, action.Y, true
@@ -251,15 +331,40 @@ func fetchHierarchy(ctx context.Context, drv driver.Driver) (*hierarchy.Tree, er
 }
 
 func traceActionFor(action verifier.Action) *trace.Action {
-	traceAction := &trace.Action{Kind: string(action.Kind)}
+	traceAction := &trace.Action{Kind: string(action.Kind), X: action.X, Y: action.Y}
 	switch action.Kind {
 	case verifier.ActionKindTap:
-		// Selector lives in the trace step's action.text field for now —
-		// trace.Action only has X/Y/Text and we don't resolve coordinates
-		// at the runner layer.
 		traceAction.Text = action.On
 	case verifier.ActionKindInputText:
 		traceAction.Text = action.Text
+	case verifier.ActionKindSwipe:
+		traceAction.FromX = action.FromX
+		traceAction.FromY = action.FromY
+		traceAction.ToX = action.ToX
+		traceAction.ToY = action.ToY
+		traceAction.DurationMillis = action.DurationMillis
+		traceAction.X = 0
+		traceAction.Y = 0
+	case verifier.ActionKindPressKey:
+		traceAction.Key = action.Key
+	case verifier.ActionKindWait:
+		traceAction.DurationMillis = action.DurationMillis
 	}
 	return traceAction
 }
+
+func traceExceptions(exceptions []verifier.Exception) []trace.Exception {
+	if len(exceptions) == 0 {
+		return nil
+	}
+	result := make([]trace.Exception, 0, len(exceptions))
+	for _, e := range exceptions {
+		result = append(result, trace.Exception{
+			Class:      e.Class,
+			Message:    e.Message,
+			StackTrace: e.StackTrace,
+			UnixMillis: e.UnixMillis,
+		})
+	}
+	return result
+}