feat: install + OS integration + full test/bench pyramid + widget (#38)

Realises the "install Neurophone on phone, integrate with OS, deploy
full
testing and benching" task end-to-end:

Build / deps
- Pin rand/rand_distr to versions compatible with ndarray-rand 0.16
  (workspace was previously broken: the rand 0.10/0.9 cross-version
  trait collision left lsm and esn uncompilable).

Subcrate implementations
- Replaced the sensors/, bridge/, llm/ stub crates with real but
  minimal implementations: per-channel IIR filters + windowed feature
  extractor; salience/urgency encoder with NL description; LlmBackend
  trait with a deterministic MockBackend so the rest of the workspace
  is testable without a 700 MB model file.

Testing pyramid (28 → 139 tests, 0 failures)
- Per-module unit tests in every crate.
- Point-to-point integration tests at crate boundaries.
- End-to-end pipeline tests through neurophone-core composing the real
  sensors + lsm + esn + bridge + llm crates.
- Aspect tests: concurrency (Arc<Mutex<...>>), timing, error paths,
  resource bounds.
- Lifecycle tests: init / start / run / shutdown / restart.

Bench coverage (8 criterion targets)
- sensors_bench, bridge_bench, llm_bench, claude_bench, esn_bench,
  lsm_bench (existing), neurophone_bench (existing), pipeline_bench
  (new E2E sensor → LLM step bench).
- TESTING-REPORT.adoc updated with median timings and frame-budget
  analysis (full non-LLM pipeline ~2.6 ms vs 20 ms 50 Hz budget).

Home-screen widget
- NeurophoneAppWidget (provider) + NeurophoneWidgetActions (state IPC)
  + NeurophoneWidgetConfigureActivity (first-run config).
- 3×2 cell layout: power toggle, refresh, salience progress bar,
  "Ask NeuroPhone" button.
- res/xml/neurophone_widget_info.xml, layout, drawables, strings.

OS integration
- NeurophoneService: foreground service that owns the sensor → neural
  → LLM loop, registers SensorManager listeners at SENSOR_DELAY_GAME,
  computes a salience signal and pushes it to the widget every 1 s.
- BootReceiver restarts the service after reboot if the user had it on.
- AndroidManifest wired with FOREGROUND_SERVICE_DATA_SYNC,
  POST_NOTIFICATIONS, RECEIVE_BOOT_COMPLETED, WAKE_LOCK; intent
  filters for ASSIST, ACTION_SEND text/plain, deep link
  neurophone://query?q=... .
- MainActivity.handleEntryIntent() handles widget tap / share / ASSIST
  / deep-link entry.
- scripts/install-on-phone.sh — workstation ADB installer (build APK,
  push model, grant runtime perms, start service).
- scripts/install-termux.sh — on-device Termux CLI installer.
- scripts/start-on-boot.sh — Termux:Boot hook.
- scripts/uninstall.sh — clean removal in either mode.
- docs/OS_INTEGRATION.adoc documents every integration surface.

Limitations
- Cannot physically install on the user's phone from this sandbox
  (no ADB / network path to a device); user runs install-on-phone.sh
  from their workstation. APK build itself requires Android NDK +
  SDK, which is not present in this environment, but all Rust code
  builds and tests cleanly on host.

https://claude.ai/code/session_012opuP3HehkjDkF1XQ8nFex

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

Cargo.lock

@@ -22,8 +22,8 @@ repository = "https://github.com/hyperpolymath/neurophone"
 # Core neural network
 ndarray = { version = "0.17", features = ["rayon", "serde"] }
 ndarray-rand = "0.16"
-rand = "0.10"
-rand_distr = "0.6"
+rand = "0.9"
+rand_distr = "0.5"
 rayon = "1.12"
 
 # Serialization

Cargo.toml

@@ -318,3 +318,95 @@ The `test_lsm_reset` test runs for ~140 seconds due to:
 The Neurophone project builds and passes all tests after fixing the rand 0.9 API migration issues. The codebase is functional but has some architectural warnings related to async/await patterns in the Android JNI bindings that should be addressed for future Rust edition compatibility.
 
 The neurosymbolic pipeline (LSM -> ESN -> Bridge -> LLM) is working correctly as demonstrated by the integration tests.
+
+== Test Pyramid Expansion (May 2026)
+
+The suite was expanded from 28 tests in a single crate to *139 tests across
+the full workspace*, organised by the standard testing-pyramid layers:
+
+[cols="1,1,4"]
+|===
+|Layer | Examples | Files
+
+|*Unit* | per-module asserts on invariants
+| `crates/<c>/src/lib.rs#tests`
+
+|*Point-to-point integration* | one-crate boundary at a time
+| `crates/sensors/tests/integration_pipeline.rs`,
+  `crates/bridge/tests/integration_encode.rs`,
+  `crates/llm/tests/integration_backend.rs`,
+  `crates/lsm/tests/integration_lsm.rs`,
+  `crates/esn/tests/integration_esn.rs`,
+  `crates/claude-client/tests/integration_routing.rs`
+
+|*End-to-end* | sensor → LSM → ESN → bridge → LLM
+| `crates/neurophone-core/tests/integration_pipeline.rs`
+
+|*Aspect* | concurrency / timing / error paths / resource bounds
+| `crates/neurophone-core/tests/aspect_concurrency.rs`,
+  `crates/{sensors,bridge}/tests/aspect_lifecycle.rs`
+
+|*Lifecycle* | init → start → run → shutdown → restart
+| `crates/neurophone-core/tests/lifecycle.rs`
+
+|*Property* | proptest on configs and event spaces
+| `crates/neurophone-core/tests/property_test.rs`
+|===
+
+Bench coverage was extended in the same way: *eight* `criterion` bench
+crates now exist (`lsm_bench`, `esn_bench`, `sensors_bench`, `bridge_bench`,
+`llm_bench`, `claude_bench`, `neurophone_bench`, `pipeline_bench`).
+
+=== Bench Results (host x86_64, release, criterion)
+
+These are reference numbers — phone numbers will differ but the relative
+shape is what matters for budgeting the 50 Hz frame (20 ms).
+
+[cols="3,2,3"]
+|===
+|Bench | Time (median) | Notes
+
+| `iir_lowpass_step_3ch`           | 33.9 ns      | per-sample
+| `iir_highpass_step_3ch`          | 68.1 ns      | per-sample
+| `windowed_features_cap50`        | 328 ns       | mean+var+L2
+| `pipeline_ingest/accelerometer_3ch` | 186 ns    | per-sample
+| `pipeline_50hz_full_second`      | 9.5 µs       | 50 ingests + features
+| `bridge_encode/lsm100_esn50`     | 791 ns       |
+| `bridge_encode/lsm512_esn300`    | 1.73 µs      | target reservoir sizes
+| `bridge_encode/lsm2048_esn1024`  | 5.24 µs      |
+| `llm_mock_generate/short`        | 150 ns       | mock backend
+| `llm_mock_generate/long_256`     | 1.90 µs      |
+| `claude/complexity_estimation`   | 635 ns       | offline scoring
+| `claude/should_use_cloud_decision` | 1.06 ns    |
+| `esn_step/50`                    | 2.07 µs      | small reservoir
+| `esn_step/300`                   | 34.2 µs      | target reservoir
+| `esn_step/1000`                  | 335 µs       | stress
+| `lsm_step_10x10x10`              | 2.62 ms      | 1000 neurons (target)
+| `e2e_to_bridge_step`             | 5.18 µs      | sensor → bridge
+| `e2e_pipeline/sensor_to_llm_step` | 6.59 µs     | full pipeline w/ mock LLM
+|===
+
+*Frame-budget analysis (50 Hz = 20 ms):*
+
+The full non-LLM pipeline (sensor → LSM → ESN → bridge) runs in
+~2.6 ms on host, leaving ~17 ms for LLM token emission. Real Llama 3.2
+1B Q4 on Dimensity 8350 is ~50–100 ms/token, so streaming tokens
+naturally span multiple sample frames — the 50 Hz inner loop never
+blocks on the LLM.
+
+== OS Integration
+
+* `scripts/install-on-phone.sh` — workstation-side ADB installer (APK +
+  optional model push + permission grant + service start).
+* `scripts/install-termux.sh` — on-device Termux installer for the CLI path.
+* `scripts/start-on-boot.sh` — Termux:Boot hook for CLI persistence.
+* `scripts/uninstall.sh` — clean uninstall in both modes.
+* `docs/OS_INTEGRATION.adoc` — full integration surface documentation.
+
+== Home-Screen Widget
+
+Live App Widget at `android/app/src/main/java/ai/neurophone/widget/`.
+Power-toggle, salience meter, "Ask NeuroPhone" button, configuration
+activity. State pushed from `NeurophoneService` every 1 s via
+`SharedPreferences` + broadcast refresh. Boot persistence via
+`BootReceiver`.