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).

pkg/spec-api/test/defaults.test.ts

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import type {
+  Action,
+  ActionGenerator,
+  EventuallyFormula,
+  Extracted,
+  Formula,
+  Sampler,
+  State,
+  UatuRuntime,
+  WeightedEntry,
+} from "../src/types.ts";
+
+interface RecordedRuntime extends UatuRuntime {
+  currentState: State;
+  extractors: Array<(state: State) => unknown>;
+  alwaysArgs: Array<(() => boolean) | Formula>;
+  lastPredicate: (() => boolean) | undefined;
+}
+
+function installRuntime(initialState: State): RecordedRuntime {
+  const extractors: Array<(state: State) => unknown> = [];
+  const extracted: Array<{ value: unknown }> = [];
+  const alwaysArgs: Array<(() => boolean) | Formula> = [];
+  let lastPredicate: (() => boolean) | undefined;
+
+  const runtime = {
+    extract: <T>(getter: (state: State) => T): Extracted<T> => {
+      extractors.push(getter as (state: State) => unknown);
+      const slot = { value: getter(state.currentState) };
+      extracted.push(slot);
+      return {
+        get current(): T {
+          return slot.value as T;
+        },
+        previous: undefined,
+      };
+    },
+    always: (predicateOrFormula: (() => boolean) | Formula): Formula => {
+      alwaysArgs.push(predicateOrFormula);
+      if (typeof predicateOrFormula === "function") {
+        lastPredicate = predicateOrFormula;
+      }
+      return { __uatuFormula: true } as Formula;
+    },
+    now: () => ({ __uatuFormula: true } as Formula),
+    next: () => ({ __uatuFormula: true } as Formula),
+    eventually: () => ({ __uatuFormula: true } as EventuallyFormula),
+    actions: (generator: () => Action[]): ActionGenerator => ({
+      __uatuActionGenerator: true,
+      generate: generator,
+    }),
+    weighted: (..._entries: WeightedEntry[]): ActionGenerator => ({
+      __uatuActionGenerator: true,
+      generate: () => [],
+    }),
+    from: <T>(_items: readonly T[]): Sampler<T> => ({ generate: () => _items[0] as T }),
+    tap: ({ on }) => ({ kind: "Tap", on }),
+    inputText: ({ into, text }) => ({ kind: "InputText", into, text }),
+    swipe: (p) => ({ kind: "Swipe", from: p.from, to: p.to, durationMillis: p.durationMillis }),
+    pressKey: ({ key }) => ({ kind: "PressKey", key }),
+    wait: ({ durationMillis }) => ({ kind: "Wait", durationMillis }),
+    taps: { __uatuActionGenerator: true, generate: () => [] } as ActionGenerator,
+    swipes: { __uatuActionGenerator: true, generate: () => [] } as ActionGenerator,
+    waitOnce: { __uatuActionGenerator: true, generate: () => [] } as ActionGenerator,
+    pressKeys: { __uatuActionGenerator: true, generate: () => [] } as ActionGenerator,
+  } satisfies UatuRuntime;
+
+  const state = { currentState: initialState };
+  const recorded = Object.assign(runtime, {
+    currentState: initialState,
+    extractors,
+    alwaysArgs,
+    get lastPredicate() {
+      return lastPredicate;
+    },
+  }) as unknown as RecordedRuntime;
+  globalThis.__uatu__ = recorded;
+  // Re-bind state ref so subsequent extract() calls read the up-to-date state.
+  Object.defineProperty(recorded, "currentState", {
+    get() {
+      return state.currentState;
+    },
+    set(next: State) {
+      state.currentState = next;
+    },
+  });
+  return recorded;
+}
+
+const emptyState: State = {
+  snapshots: {},
+  ax: { find: () => undefined, findAll: () => [] },
+  lastAction: null,
+  time: 0,
+  logs: [],
+  exceptions: [],
+};
+
+test("defaults bundle exports formulas tagged as LTL properties", async () => {
+  installRuntime({
+    ...emptyState,
+    logs: [{ unixMillis: 1, level: "W", tag: "X", message: "warn" }],
+  });
+  const defaults = await import("../src/defaults/properties.ts");
+  assert.equal(defaults.noUncaughtExceptions.__uatuFormula, true);
+  assert.equal(defaults.noLogcatErrors.__uatuFormula, true);
+});